Seguridad en SSH

Usa contraseñas fuertes

Una contraseña fuerte es una cadena que ningún atacante podría adivinar ni de casualidad ni con unas pocas horas de fuerza bruta.

Intenta elegir contraseñas con:

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

Hay 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 que generan esos programas son, desde luego, seguras. Pero son muy difíciles de recordar, así que tendrás que apuntarlas en algún sitio. Por eso te recomiendo encarecidamente que crees una frase (passphrase) larga que tú (y solo tú) puedas memorizar.

Desactiva el login de root por SSH

• Edita esta línea del archivo /etc/ssh/sshd_config:

  PermitRootLogin no
  

• Reinicia el demonio:

  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 unos pocos usuarios necesitan entrar al sistema por ssh. Añade esta línea a /etc/ssh/sshd_config:

AllowUsers usr_1 usr_2 usr_3

Desactiva el “Protocol 1”

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

Cambia el puerto

Por defecto el puerto de ssh es el 22. Cámbialo a un número cualquiera, preferiblemente por encima de 1024. Por ejemplo: Port 2345

Fíjate en que ahora habrá que indicar siempre a qué puerto conectarse:

ssh -p 2345 julio@casa.juliobs.com

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

Usa un cortafuegos

Podemos configurar iptables para que solo algunas IP concretas puedan conectarse al puerto de SSH:

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

Yo no puedo usar la opción anterior, porque a menudo necesito conectarme desde IP distintas. Así que una solución más interesante es limitar el número de intentos desde una misma IP.

Registra la IP que ha intentado acceder al puerto 22 y rechaza los paquetes si esa misma IP lo ha intentado 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

Corta la conexión si la misma IP intenta conectarse 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ública/privada para autenticarte

1. Crea una clave:

   $ ssh-keygen -t rsa -b 4096 -f servidorx -C "pubkey para el 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 el 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 que sea exagerado, pero nunca se sabe.

   Actualización de 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'
   

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

3. Comprueba que los permisos son correctos:

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

4. Crea el archivo ~/.ssh/config, que contiene algunos ajustes 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 algo la vida, porque ya no hace falta recordar el nombre de usuario, la dirección completa del servidor ni el puerto.

   En vez de conectarnos al servidorX con:

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

   Podemos simplemente:

   ssh servidorx
   

Links

• 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