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.

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



Subsecciones
Casiano Rodríguez León
Licencia de Creative Commons
Programación Distribuida y Mejora del Rendimiento
por Casiano Rodríguez León is licensed under a Creative Commons Reconocimiento 3.0 Unported License.

Permissions beyond the scope of this license may be available at http://campusvirtual.ull.es/ocw/course/view.php?id=44.
2012-06-19