Seguridad SSH

Usa contraseñas fuertes

Las contraseñas fuertes consisten en una cadena que ningún atacante podría adivinar ni por tanteo ni con un ataque de fuerza bruta de pocas horas.

Procura elegir contraseñas con:

• Al menos 15 caracteres.
• Combinación de letras (mayúsculas y minúsculas), números y caracteres no alfanuméricos.

Existen programas como pwgen, makepasswd, apg, KeePassX y comandos de Unix que generan contraseñas aleatorias seguras:

tr -dc '_A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' < /dev/urandom | head -c25

pwgen -cnsy 25 1

Opciones de pwgen:

• -c: al menos una letra mayúscula.
• -n: al menos un carácter numérico.
• -s: al menos un carácter especial.
• -y: excluye caracteres ambiguos (como l, 1, I, 0, O, etc.).
• 25: longitud de la contraseña.
• 1: cuántas contraseñas generar.

Las contraseñas generadas por esos programas son, de hecho, seguras. Pero son muy difíciles de recordar, lo que hace que tengas que anotarlas en algún lugar. Por lo tanto, recomiendo encarecidamente que crees una frase larga (passphrase) que tú (y solo tú) puedas memorizar.

Deshabilita el login de root por SSH

• Edita la siguiente línea en el archivo /etc/ssh/sshd_config:

  PermitRootLogin no
  

• Reinicia el daemon:

  sudo /etc/rc.d/sshd restart
  

  o, si usas systemd:

  julio@acer ~> sudo systemctl restart sshd
  

Cuando necesites acceso como root, usa el comando su.

Limita quién puede iniciar sesión por ssh

Es útil cuando solo algunos usuarios necesitan acceder al sistema por ssh. Añade la siguiente línea en /etc/ssh/sshd_config:

AllowUsers usr_1 usr_2 usr_3

Desactiva “Protocol 1”

SSH posee dos protocolos. Como el Protocol 1 es antiguo e inseguro, descomenta la línea Protocol 2.

Cambia el puerto

Por defecto, el puerto usado para ssh es el 22. Cámbialo por algún número aleatorio, preferiblemente por encima de 1024. Ejemplo: Port 2345

Observa que ahora siempre tendremos que indicar a qué puerto conectar:

ssh -p 2345 julio@casa.juliobs.com

Aquí también tuve que abrir el puerto (solo TCP) en mi router.

Usa un firewall

Podemos configurar iptables para permitir que solo algunas IP concretas se conecten al puerto utilizado por SSH:

iptables -A INPUT -p tcp -s 201.43.81.111 --dport 22 -j ACCEPT

Aquí no puedo utilizar la opción anterior, pues a menudo necesito conectarme desde IPs diferentes. Por lo tanto, una solución más interesante es limitar la cantidad de intentos que vienen de la misma IP.

Registra la IP que intentó acceder al puerto 22 y rechaza los paquetes si la misma IP intentó conectar 4 veces o más en el último minuto:

iptables -A INPUT -p tcp --dport 22 -m recent --set --name ssh --rsource

iptables -A INPUT -p tcp --dport 22 -m recent ! --rcheck --seconds 60 \
         --hitcount 4 --name ssh --rsource -j ACCEPT

Cancela la conexión si la misma IP intenta conectar más de 3 veces al puerto 22 en el mismo minuto:

iptables -A INPUT -p tcp --dport 22 --syn -m limit --limit 1/m --limit-burst 3 -j ACCEPT

iptables -A INPUT -p tcp --dport 22 --syn -j DROP

Usa claves públicas/privadas para autenticación

1. Crea una clave:

   $ ssh-keygen -t rsa -b 4096 -f servidorx -C "pubkey para servidor X"
       Generating public/private rsa key pair.
       Enter passphrase (empty for no passphrase):
       Enter same passphrase again:
       Your identification has been saved in servidorx.
       Your public key has been saved in servidorx.pub.
       The key fingerprint is:
       e1:5c:44:b2:f4:48:c7:22:62:16:99:fb:44:11:23:a7 pubkey para servidor X
       The key's randomart image is:
       +--[ RSA 4096]----+
       |    o+=o+o+      |
       |    *+o+.B.      |
       |   oE+ .+.o      |
       |    . .o o       |
       |     o  S        |
       |      .          |
       |                 |
       |                 |
       |                 |
       +-----------------+
   

   El algoritmo por defecto de ssh-keygen es RSA de 2048 bits; en este ejemplo usé RSA de 4096 bits. Puede ser un exceso, pero nunca se sabe.

   Actualización 2020: RSA 4096 sigue siendo seguro, pero lo recomendado es Ed25519: ssh-keygen -t ed25519 -f servidorx -C "pubkey".

2. Copia la clave al servidor remoto.

   ssh-copy-id -i servidorx.pub '-p 2345 julio@servidorx.com'
   

   Este comando es equivalente a concatenar el archivo ~/.ssh/authorized_keys del servidor remoto con la clave pública servidorx.pub.

3. Asegúrate de que los permisos sean correctos:

   chmod 700 ~/.ssh
   chmod 600 ~/.ssh/servidorx
   

4. Crea el archivo ~/.ssh/config, que contiene algunas configuraciones por host, atajos y alias útiles:

   Host github.com
       HostName        github.com
       IdentityFile    ~/.ssh/github
       User            jbsilva
   
   Host juliobs.com
       HostName        juliobs.com
       IdentityFile    ~/.ssh/juliobs
       User            julio
   
   Host servidorx
       HostName        ssh.servidorx.com
       IdentityFile    ~/.ssh/servidorx
       User            usuariox
       Port            2345
   

   Este archivo nos facilita la vida, pues ahora no necesitamos recordar el nombre de usuario, la dirección completa del servidor ni el puerto.

   En lugar de conectarnos a servidorX usando:

   ssh -i servidorx -p 2345 usuariox@ssh.servidorx.com
   

   Podemos simplemente:

   ssh servidorx
   

Enlaces

• http://wiki.centos.org/HowTos/Network/SecuringSSH
• http://techie-buzz.com/foss/change-default-ssh-port-in-linux.html
• https://wiki.archlinux.org/index.php/Using_SSH_Keys