El fichero authorized_keys

Cada línea del fichero SSH1 authorized_keys (habitualmente en ~/.ssh/authorized_keys) contiene una clave pública. Tiene el siguiente formato: Cada entrada va en una sóla línea. Los campos se separan por comas. Las líneas en blanco y las que empiezan por # se ignoran.

• Primero van las opciones, separadas por comas, por ejemplo:
  • from="pattern-list" El servidor sshd puede limitar que máquinas pueden conectarse a la máquina usando wrappers TCP, pero no a nivel de usuario. Utilizando esta opción es posible limitar las conexiones para una identidad a un conjunto especifico de máquinas. Los hosts se separan por comas y pueden contener comodines como * y ?. Se pueden rechazar hosts específicos prefijándolos con !. Por ejemplo:

          from="!enemy.my_isp.net,*.my_isp.net,home.example.com"
    

  • command="command"
  • environment="NAME=value" Se usa si se quiere tener un entorno específico cuando se usa esta clave. Por ejemplo podemos poner un $PATH restrictivo para que no pueda ejecutar ciertos comandos, cambiar $HOME, etc.

    Si se tiene varias personas accediendo via diferentes identidades a la misma cuenta - usando tal vez un comando forzado - puede ser útil establecer la variable $LOGNAME de manera que identifique quién se conecta.

  • nopty
  Este campo es opcional. Su presencia se detecta viendo si la línea comienza por un número o no
• La clave pública: bits, exponente y módulo
• Un comentario (user@machine.domain.es en el ejemplo que sigue)

Sigue un ejemplo. Primero generemos una pareja especial para esto:

$ ssh-keygen -tdsa -C 'limited command to millo' -P '' -f ~/.ssh/limited_command
$ ssh-copy-id -i ~/.ssh/limited_command.pub millo

Ahora podemos entrar a la máquina usando esa pareja con:

$ ssh -i ~/.ssh/limited_command millo
Last login: Mon Apr 20 09:05:11 2009 from 192.168.100.242
millo:~$ vi ~/.ssh/authorized_keys
millo:~$

Editamos el fichero ~/.ssh/authorized_keys y añadimos la opción comando

17 # Prueba de comando limitado
18 command="ls" ssh-dss AAAAB3NzaC1kc3...= limited command to millo

La presencia de la opción command permite dar acceso a nuestra cuenta a usuarios restringiendo el uso de los comandos que pueden utilizar.

tonga:~/.ssh$ ssh -i ~/.ssh/limited_command millo
ADVENS_OF_SHERLOCK.html  cshrc       Imágenes  LSimple-Scope     
asignas                  Desktop     LEyapp    machines.sample  
autosave                 doc         Llhp      Makefile.PL     
bidirwithnamedpipes.pl   Documentos  LPLdoc    Música         
bin                      exrc        LPLsrc    myprofile     
cat                      help        LPL-Tutu  Net-ParSCP.tar.gz 
Connection to millo closed.

Es posible obtener los argumentos escritos en la línea de comandos de la llamada al cliente consultando la variable de entorno SSH_ORIGINAL_COMMAND. Existen otras variables de entorno que están definidas cuando se ejecuta una conexión (véase la sección ENVIRONMENT en la página del manual de ssh) Para ilustrar el punto usaremos el siguiente programa como comando forzado:

$ cat -n get_ssh_env
 1  #!/usr/bin/perl -w
 2  use strict;
 3
 4  my @keys = qw{
 5         SSH_ORIGINAL_COMMAND
 6         SSH_CONNECTION
 7         SSH_AUTH_SOCK
 8         SSH_TTY
 9         DISPLAY
10         HOME
11         LOGNAME
12         MAIL PATH TZ USER
13      };
14  my ($args, $con, $sock, $tty,
15      $display, $home, $logname, $mail, $path, $tz, $user
16     ) = map { $ENV{$_} || '' } @keys;
17
18  print << "INFO";
19  args=<$args>
20  con=<$con>
21  sock=<$sock>
22  tty=<$tty>
23  display=<$display>
24  home=<$home>
25  logname=<$logname>
26  mail=<$mail>
27  path=<$path>
28  tz=<$tz>
29  user=<$user>
30  INFO

Cuando se fuerza en authorized_keys y se ejecuta la conexión se obtiene:

casiano@tonga:~$ ssh -i ~/.ssh/show_arguments millo chum cham chim
args=<chum cham chim>
con=<XXX.XXX.XXX.XXX 55286 XXX.XXX.XXX.XXX 22>
sock=<>
tty=<>
display=<localhost:11.0>
home=</home/casiano>
logname=<casiano>
mail=</var/mail/casiano>
path=</usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/soft/perl5lib/bin:/home/casiano/bin>
tz=<>
user=<casiano>

Si el administrador tiene configurada la opción PermitUserEnvironment de sshd_config a yes (el valor por defecto es no), ssh leerá el fichero ~/.ssh/environment (si existe) añadiendo al entorno líneas con el formato VARNAME=value.

Ejercicio 2.1.13   El módulo Safe permite restringir los comandos disponibles en Perl:

Ejemplo

pp2@europa:~/src/perl/perltesting$ cat -n safe.pl
 1  #!/usr/bin/perl -w
 2  use strict;
 3  use Safe;
 4  use Data::Dumper;
 5
 6  my $compartment = new Safe;
 7
 8  $compartment->permit(qw(time :browse));
 9
10  my $unsafe_code = <>;
11  my $result = $compartment->reval($unsafe_code);
12
13  if (defined($result)) {
14    if (ref($result)) {
15      $Data::Dumper::Varname = 'RESULT';
16      $Data::Dumper::Indent = 1;
17      print Dumper($result);
18    }
19    else {
20      print $result."\n";
21    }
22  }
23  else {
24    print "Illegal code\n";
25  }

Ejecución

pp2@europa:~/src/perl/perltesting$ ./safe.pl
[1..5]
$RESULT1 = [
  1,
  2,
  3,
  4,
  5
];
pp2@europa:~/src/perl/perltesting$ ./safe.pl
system('rm -fR')
Illegal code

Establezca un comando forzado para una clave dada de manera que la conexión con la máquina remota permita la ejecución del comandos perl 'seguro' (usando Safe) especificado por el usuario en la línea de comandos.

Ejercicio 2.1.14   Establezca un comando forzado para una clave dada de manera que la conexión con la máquina remota de lugar a una conexión ssh con una segunda máquina remota:

casiano@tonga:~/.ssh$ ssh -i ~/.ssh/sshhophop millo
Last login: Mon Apr 20 11:35:38 2009 from millo
casiano@cc116:~$

Cuando se usa un comando forzado es conveniente

• Asegúrese que el comando es lo suficientemente restrictivo para impedir la aparición de problemas de seguridad. Existen shell restringidas como rssh que pueden ayudar.
• Usar la opción from="pattern-list" para limitar las máquinas desde las que se puede realizar la conexión
• Usar la opción environment="NAME=value" para limitar el $PATH (lo mas restrictivo posible) y cambiar $HOME. Esto sólo es posible si la opción PermitUserEnvironment no ha sido desactivada por el administrador. Si no es así, cámbielos en el código del propio comando.
• Identifique quién se conecta. Cada usuario del comando forzado tendrá una identidad distinta y el comando forzado se llamará desde la identidad como comando usuario.
• Es conveniente que el comando tenga un servicio de "log" de manera que las incidencias queden registradas en un fichero (Log::Log4Perl)
• Aunque en el ejemplo no hemos usado passphrase, es conveniente que una clave de comando forzado se use con passphrase. El usuario deberá usar el agente ssh para evitar la introducción repetida de la clave.
• Inhibir port-forwarding, X11 forwarding y el acceso a seudoterminal. Para ello se añaden estas opciones al comando forzado:

  command="/bin/ps -ef",no-port-forwarding,no-X11-forwarding,no-pty ssh-rsa AAAAB...= Test key