Autenticación basada en llaves para SSH

Introducción.

A diario utilizamos el protocolo SSH para establecer conexiones seguras entre servidores y acceder a shells remotos, montar sistemas de archivos remotos y crear túneles entre muchas otras facilidades.  Habitualmente nos autenticamos ante el servidor remoto utilizando contraseñas, es decir, para indicarle quienes somos le enviamos nuestro nombre de usuario y para garantizarle al servidor que efectivamente somos quienes decirmos ser, el enviamos nuestra contraseña, la cual es secreta y sólo el servidor y nosotros la conocemos.

Este es el método de autenticación mas utilizado y viene por defecto con la instalación del servicio SSH, sin embargo no es muy práctico cuando es necesario interactuar en múltiples ocasiones con múltiples servidores ya que será necesario ingresar la contraseña para autenticarnos múltiples veces.  Una solución a este problema es el uso de llaves (privada y pública) para autenticarnos con el servidor remoto.

El procedimiento es simple, el cliente crea su propio par de llaves y le envía al servidor remoto su llave pública.  En el servidor se agrega esta llave recibida a la lista de llaves autorizadas para su conexión.

La próxima vez que el usuario (que cuenta con sus llaves) intenta acceder al servidor a su cuenta (que cuenta con su llave pública autorizada), este último utilizará el método basado en llaves para autenticarlo con el cual no será necesario que ingrese su contraseña nuevamente.

En este punto es necesario hacer una aclaración, la idea fundamental es la de evitar la necesidad de especificar la contraseña del usuario frecuentemente, sin embargo la llave privada del usuario viene por defecto encriptada con una passphrase, la cual debe especificarse cada vez que el usuario la va a utilizar.

La diferencia de uso entre la contraseña y la passphrase es que esta última puede ser recordada mediante agentes SSH los cuales almacenan las passphrases la primera vez que se utilizan y la proveen automáticamente en las veces subsecuentes, es decir, en una sesión de trabajo sólo será necesario escribir una única vez la passphrase específica de una llave para la autenticación basada en estas.

Existen distintos agentes SSH como ssh-agent (incluído con OpenSSH), GNUPG Agent que tiene emulación para OpenSSH, keychain y GNOME Keyring entre otros.  En mi caso utilizo GNOME así que utilizo el Keyring que viene con él por defecto.

Configuración.

Crear las llaves en el cliente.

En el cliente se inicia creando la pareja de llaves, pública y privada.

$ ssh-keygen -b 1024 -t dsa

Generating public/private dsa key pair.
Enter file in which to save the key (/home/jimezam/.ssh/id_dsa):   [1]
Enter passphrase (empty for no passphrase):                        [2]
Enter same passphrase again:                                       [3]
Your identification has been saved in /home/jimezam/.ssh/id_dsa.
Your public key has been saved in /home/jimezam/.ssh/id_dsa.pub.
The key fingerprint is:
55:32:22:01:1f:b3:5c:f1:44:28:49:55:93:55:f9:1f jimezam@micliente
The key’s randomart image is:
+–[ DSA 1024]—-+
|        ..*=*=+++|
|         o.Ooo.=.|
|          =  .=  |
|         .     . |
|        S       .|
|                E|
|                .|
|                 |
|                 |
+—————–+

Se recomienda utilizar la ubicación sugerida por defecto [1] para el almacenamiento de las llaves.  En este punto [2] debe especificarse el passphrase (concepto que se introdujo en la sección anterior) para cifrar la llave privada, es necesario que recuerde muy bien la cadena de texto que utilizó ya que debe ser utilizada durante su confirmación [3] y una vez por sesión cada vez que vaya a realizar la autenticación basada en llaves con otro servidor.

Terminado este procedimiento se deberá tener dos archivos nuevos con las llaves recién generadas: id_dsa.pub es la llave pública y id_dsa es la llave privada.

$ file ~/.ssh/id_dsa.pub

id_dsa.pub: OpenSSH DSA public key

$ file ~/.ssh/id_dsa

id_dsa: PEM DSA private key

Transmitir la llave pública al servidor.

El siguiente paso es el de transmitir la llave pública del usuario en el cliente al servidor.

$ scp ~/.ssh/id_dsa.pub jimezam@miservidor:

Autorizar en el servidor la llave pública enviada desde el cliente.

Se autoriza la llave pública enviada desde el cliente para que el servidor confíe en ella la próxima vez que el primero intente autenticarse.  Para esto se realiza una conexión remotoa con el servidor.

$ ssh jimezam@miservidor

Ya en el servidor se ejecutan los siguientes comandos.

$ mkdir ~/.ssh

$ chmod go-w ~/.ssh

$ cat ~/id_dsa.pub >> ~/.ssh/authorized_keys

$ rm ~/id_dsa.pub

$ chmod 600 ~/.ssh/authorized_keys

Utilización.

La próxima vez que el usuario (con las llaves) intenta acceder a través de SSH al servidor (que confía en la llave pública) el agente SSH que esté utilizando (en mi caso GNOME) le solicitará una única vez el passphrase de la llave privada [2] y de allí en adelante autenticará de manera transparente las demás sesiones que abra el usuario.

$ ssh jimezam@miservidor

GNOME Keyring solicitando una passphrase

Enlaces.

para que confíe en ella la próxima vez que el primero intente autenticarse.

One thought on “Autenticación basada en llaves para SSH”

Leave a Reply

Your email address will not be published. Required fields are marked *