Curso Consola

          Taller: Consola, esa gran desconocida
Este es el material de apoyo para el taller Consola, esa gran desconocida organizado por la
Asociación de Usuarios de Software Libre de Elche, Kleenux, el 7 de mayo de 2005.
Autores:        Mariano Cediel                      <mariano.cediel@gmail.com>
Jose Fco. Irles                     <josefu@sdf-eu.org>
Copyright © 2005 Mariano Cediel y Jose Fco. Irles. Se permite la copia textual y distribución de
este documento en su totalidad, por cualquier medio, siempre y cuando se mantenga esta nota de
copyright.
Más información sobre la Asociación de Usuarios de Software Libre de Elche en
http://www.kleenux.org.
Tabla de contenidos
1. Arranque del sistema ………………………………………………………………………………………2
2. Personalizando el sistema ……………………………………………………………………………….4
3. Permisos en sistemas *NIX ……………………………………………………………………………..8
4. Más fácil en consola ……………………………………………………………………………………….9
5. Tareas automatizadas con Cron ………………………………………………………………………10
6. Scripting ……………………………………………………………………………………………………..11
7. SSH: administración remota ………………………………………………………………………….14
8. Gestión de software en Ubuntu ………………………………………………………………………16
A. Documentación adicional ………………………………………………………………………………18

1. Arranque del sistema (grub)
En los sistemas *NIX, por regla general, suelen necesitar la instalación de un cargador de
arranque en el MBR (Master Boot Record) que se encarga de cargar el kernel seleccionado en la
posición de memoria adecuada para que se ejecute en nuestra computadora.
El cargador de arranque más utilizado hasta ahora ha sido Lilo (Linux LOader), no obstante,
desde hace unos años, Grub esta empezando ha implantarse con fuerza en las grandes
distribuciones debido a su mayor potencia.
Configuración de ejemplo de grub: boot/grub/menu.lst
# —————————————————
# menu.lst – See: grub(8), info grub, update-grub(8)
default                1
timeout                5
color cyan/blue white/blue
# — una debian y una ubuntu
title           Debian GNU/Linux, kernel 2.6.8-2-686
root            (hd0,1)
kernel                 /boot/vmlinuz-2.6.8-2-686 root=/dev/hda2 ro
initrd                 /boot/initrd.img-2.6.8-2-686
savedefault
boot
title           Ubuntu Hoary
root            (hd0,2)
kernel                 /boot/vmlinuz-2.6.10-2 root=/dev/hda2 ro
initrd                 /boot/initrd.img-2.6.10-2
savedefault
boot
## — el lado oscuro.
title           El lado oscuro:
root
title           Microsoft Windows XP Home Edition
root            (hd0,0)
savedefault
makeactive
chainloader     +1
## — FIN —
Como podemos observar, los principales parámetros de configuración son bastante auto
explicativos:
default
Establece como opción por defecto la número num. La numeración empieza en 0, y la número 0
es la opción por defecto si no se usa esta orden.
timeout
Fijar el tiempo de espera en sec segundos, antes de arrancar automáticamente la opción por
defecto (normalmente la primera definida).
title
Título que aparecerá en el menú de arranque
root
Sólo válida para sistemas Linux, indica la partición raíz (root) del sistema.
kernel
Indica la ruta completa en nuestra partición raíz, al binario del kernel; así como los parámetros
que deseemos pasarle.
initrd
Indica la ruta completa en nuestra partición raíz a la imagen initrd que utilizará nuestro kernel
(opcional)
boot
Arranca el SO/gestor de arranque que ha sido cargado. Sólo es necesario cuando se arranca
interactivamente desde la línea de órdenes (ya que está implícita en el final de una entrada del
menú).
savedefault
Guarda la opción de menú actual como la opción por defecto
chainloader
Carga en cadena archivo como gestor de arranque. Como con cualquier otro archivo que se carga
mediante el código del sistema de ficheros, se puede utilizar la notación de lista de bloques
`+1′ para capturar el primer sector de la partición actual.
makeactive
Marca la partición como activa
Elaborar un diskette de arranque
# mke2fs /dev/fd0
# mount -t ext2 /dev/fd0 /floppy
# mkdir -p /floppy/boot/grub
# cd /boot/grub
# cp stage1 stage2 menu.lst /floppy/boot/grub
# umount /floppy
# /sbin/grub –batch –device-map=/dev/null <<EOT
device (fd0) /dev/fd0
root (fd0)
setup (fd0)
quit
EOT
Recuperación del cargador de arranque
Si alguna vez habéis reinstalado windows y tenias un linux instalado, habréis observado
impotentes como el instalador del primero se carga sin contemplaciones nuestro cargador de
arranque, no pudiendo arrancar nuestro querido linux. Vamos a aprender como recuperar nuestro
sistema a partir de un liveCD.
1. Arrancamos el sistema desde la distribución del CD.
2. Obtenemos una consola de root (mediante su).
3. Montamos en modo lectura/escritura la partición raíz del linux instalado en nuestra máquina:
# mount -t ext3 -rw /dev/hda2 /mnt/hda2

4. Ejecutamos chroot para cambiar nuestro directorio raíz al de nuestro sistema instalado:
# chroot /mnt/hda2
5. Ejecutamos el instalador de nuestro cargador de arranque:
# grub-install ‘(hd0)’
Recuperación del sistema sin el password de root
Si por cualquier motivo necesitamos obtener la cuenta root de una máquina de la que no tenemos
su password o lo hemos olvidado, existe una manera de logearse en el sistema sin ingresar
ninguna contraseña.
1. Iniciamos el sistema y detenemos grub en la primera fase pulsando Esc.
2. Pulsamos la tecla e para editar los parámetros que se le pasan al kernel en el arranque.
3. Añadimos, a los parámetros existentes, los siguientes (están en negrita):
grub edit> kernel /boot/vmlinuz-<versión del kernel> root=/dev/hda2 ro quiet
splash rw init=/bin/sh
4. Pulsa b para arrancar y en pocos segundos tendrás una shell con permisos de root en la que
podrás ejecutar el comando passwd para cambiar la contraseña de root.
2. Personalizando el sistema
Cada administrador de sistemas tiene sus truquillos y sus manías, por lo que la personalización
de la consola es lo primero que todo administrador suele hacer al usar un sistema nuevo. Aquí
vamos a trabajar sobre la shell bash debido a que es la instalada por defecto en ubuntu, no
obstante, la mayoría de lo que aquí haremos es extrapolable a otras shell’s.
.bashrc
Este fichero se carga cada vez que ejecutamos un intérprete de comandos bash. En él, podemos
establecer variables de entorno, alias, etc; a continuación vamos a ver un ejemplo de .bashrc:
# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples
# If running interactively, then:
if [ “$PS1” ]; then
# don’t put duplicate lines in the history. See bash(1) for more options
# export HISTCONTROL=ignoredups
# check the window size after each command and, if necessary,
# update the values of LINES and COLUMNS.
#shopt -s checkwinsize
# enable color support of ls and also add handy aliases
if [ “$TERM” != “dumb” ]; then
eval `dircolors -b`
alias ls=’ls –color=auto’
#alias dir=’ls –color=auto –format=vertical’
#alias vdir=’ls –color=auto –format=long’
fi
# some more ls aliases
alias ll=’ls -l’
alias la=’ls -A’
alias l=’ls -CF’

# set a fancy prompt
PS1=’\u@\h:\w\$ ‘
# If this is an xterm set the title to user@host:dir
#case $TERM in
#xterm*)
#       PROMPT_COMMAND=’echo -ne “33]0;${USER}@${HOSTNAME}: ${PWD}07″‘
#       ;;
#*)
#       ;;
#esac
# enable programmable completion features (you don’t need to enable
# this, if it’s already enabled in /etc/bash.bashrc).
#if [ -f /etc/bash_completion ]; then
# . /etc/bash_completion
#fi
Podemos observar el uso del comando alias que nos permite redefinir aquellos comandos que
utilicemos con mayor frecuencia de manera más corta o de una forma más fácil de recordar.
La variable PS1 se refiere al prompt de nuestra consola, el cuál podremos personalizar para que
aparezca lo que nosotros queramos. Estas son algunas de las variables que podemos utilizar:
\h es el nombre de host hasta el primer punto.

\H el nombre completo del host.

\n nueva línea.

\s es el nombre del shell, en nuestro caso, “bash”

\t es la hora en formato 24 horas.

\u es el nombre del usuario actual

\v es el número de versión de bash.

\w es el directorio de trabajo actual.

Dentro de esta variable, PS1, también podemos hacer que se sustituya la salida de cualquier
comando igual que hacemos en los scripts. Prueba con PS1=$(date).
Podemos hacer que partes del prompt aparezcan en color. Lo que queramos que aparezca entre
colores, lo precederemos por \[33[COLORm\] , teniendo en cuenta que al final del prompt
debemos restablecer el color nulo si no queremos que los comandos que escribamos salgan en
color. Esto lo conseguimos con \[33[0m\] . COLOR puede ser una secuencia con formato
A;B, donde A vale 0 ó 1 y B vale desde 30 a 37.
Combinación          Color
0;30            negro
0;31             rojo
0;32            verde
0;33           marrón
0;34             azul
0;35           púrpura
0;36             cían
0;37          gris claro

1;30         gris oscuro
1;31          rojo claro
1;32         verde claro
1;33           amarillo
1;34          azul claro
Colores de fondo
40             Negro
41              Rojo
42             Verde
43            Marrón
44              Azul
45            Púrpura
56           Turquesa
47              Gris
1;35       púrpura claro
1;36          cían claro
1;37            blanco
Por ejemplo, para un prompt con el usuario, host y el directorio de trabajo de color rojo (para el
usuario root por ejemplo), utilizaríamos la siguiente línea en nuestro .bashrc:
export PS1=’\[33[1;31m\][\u@\h:\w]\$ \[33[0m\]’
Los colores de fondo se usan precediendo el valor del color del fondo a los ya vistos para el
color de las letras. Por ejemplo, \[33[41;1;33m\] producirá texto amarillo sobre fondo rojo.
Hay que tener en cuenta que 33 y \e son equivalentes y pueden usarse indistintamente.
.bash_profile
Este archivo se carga antes que el .bashrc, y aquí podremos modificar variables de entorno como
cambiar nuestro $PATH para incluir en él algún directorio con binarios personales.
# ~/.bash_profile: executed by bash(1) for login shells.
# see /usr/share/doc/bash/examples/startup-files for examples.
# the files are located in the bash-doc package.
# the default umask is set in /etc/login.defs
#umask 022
# the rest of this file is commented out.
# include .bashrc if it exists
if [ -f ~/.bashrc ]; then
source ~/.bashrc
fi
# set PATH so it includes user’s private bin if it exists
#if [ -d ~/bin ] ; then
#     PATH=~/bin:”${PATH}”
#fi

# do the same with MANPATH
#if [ -d ~/man ]; then
#      MANPATH=~/man:”${MANPATH}”
#      export MANPATH
#fi
/etc/issue
En este archivo se almacena el mensaje que se muestra en una consola local cuando nos
disponemos a realizar nuestro login, podemos personalizarlo para adaptarlo a nuestras
necesidades. También existe el archivo /etc/issue.net que es el utilizado cuando se realiza un
login remoto.
Algunas de las variables que podemos utilizar para personalizar nuestro login son:
\b Inserta la velocidad en baudios de la línea actual.

\d Inserta la fecha actual.

\s Inserta el nombre del sistema, el nombre del sistema operativo.

\l Inserta el nombre de la línea tty actual.

\m Inserta el identificador de la arquitectura de la máquina, i386 por ejemplo.

\n Inserta el nombre de nodo de la máquina, también conocido como nombre de máquina

(hostname).
\o Inserta el nombre del dominio de la máquina.

\r Inserta la versión del núcleo, por ejemplo 2.6.10.

\t Inserta la hora actual.

\u Inserta el número de usuarios conectados en ese momento.

\U Inserta la cadena “1 user” o “<n> users” dónde <n> es el número de usuarios conectados en

ese momento.
\v Inserta la versión del SO, por ej. la fecha de creación, etc.

En Ubuntu, el fichero /etc/issue tiene el siguiente aspecto:
# cat /etc/issue
Ubuntu 5.04 “Hoary Hedgehog” \n \l
/etc/motd
Este archivo contiene un mensaje de bienvenida que se muestra al usuario cuando se produce un
login (ya sea remoto o local). Este archivo se regenera en cada arranque, por lo que si queremos
conservar los cambios, deberemos modificar a en el archivo /etc/default/rcS la variable
EDITMOTD y establecerla a no.

3. Permisos en sistemas *NIX
Bajo Unix un fichero tiene permisos y un propietario, que pertenece a un grupo. Mire este
ejemplo:
$ ls -l /bin/ls
-rwxr-xr-x 1 root root 75948 2004-07-16 13:37 /bin/ls
El primer campo contiene los permisos del fichero /bin/ls, que pertenece a root, del grupo root.
En este primer campo, en este caso, se especifica lo siguiente:
–       es el tipo de fichero (- = fichero normal, d = directorio, l = enlace, etc.)
rwx     son los permisos del propietario del fichero (leer, escribir y ejecutar)
r-x     son los permisos para el grupo del propietario del fichero (leer y ejecutar)
r-x     son los permisos para todos los demás usuarios del sistema (leer y ejecutar)
Para cambiar los permisos sobre un fichero se utiliza el comando:
# chmod <quienXper> fichero
Donde quien puede ser:
u   usuario (propietario)

g   grupo

o todos (all)

X puede ser + (para añadir) o – (para quitar)
per puede ser:
r   lectura

w   escritura

x   ejecución

Ejemplos:
$ chmod u+x fichero
esto habilita el permiso de ejecución para el propietario del fichero.
$ chmod go-wx fichero
esto quita el permiso de escritura y de ejecución para todo el mundo menos al usuario.
$ chmod ugo+rwx fichero
esto le da a todo el mundo el permiso de lectura, escritura y ejecución.
$ chmod +s fichero
esto convierte al fichero en setuid o suid, esto es, un fichero que al ejecutarse lo hace con
privilegios de root.
Una manera más corta de referirse a los permisos es con números:
rwxr-xr-x puede ser expresado como 755, cada letra corresponde a un bit:
—     es 0
–x     es 1
-w-     es 2
r–     es 4
Por eso el primer grupo de 3 (rwx) sería 7 (4+2+1), el segundo grupo (r-x) sería 5 (4+1) y el
tercer grupo sería 5 (4+1)

4. Más fácil en consola
Esto no es más que una pequeña recopilación de comandos y combinación entre ellos que nos
pueden facilitar nuestro trabajo:
Arrancando, parando servicios:

# /etc/init.d/<servicio> start | stop | restart | reload
Añadir un script personalizado que se ejecute al iniciar la máquina:

# cp <nuestro script> /etc/init.d/ (copiamos el script a la carpeta /etc/init.d)
# update-rc.d <nuestro script> defautls
Evitar que un script de arranque del sistema se ejecute en cada inicio:

# update-rc.d -f <nuestro script> remove
Buscando una cadena de texto en un fichero:

# grep <texto> fichero (distingue ente mayús. y minús.)
# grep -i <texto> fichero (no distingue entre mayús. y minús.)
Ver los procesos que se están ejecutando:

# top
Matar un proceso con un PID en concreto:

# kill -9 <PID de proceso>
Matar todos los procesos de un comando en concreto:

# killall <proceso>
# killall apache (ejemplo para matar todos los procesos ‘apache’)
Buscando si un proceso esta activo:

# ps aux | grep <nombre del proceso>
Observando que pasa en el sistema en “tiempo real”:

# tail -f /var/log/syslog
Servicios que estan escuchando la red:

# netstat -atu
# netstat -tan (tcp sin resolución de nombres)
# netstat -uan (udp sin resolución de nombres)
Saber el PID de un proceso que esta ecuchando en un puerto en concreto:

# fuser -n tcp <puerto> (para puertos tcp)
# fuser -n udp <puerto> (para puertos udp)
Mostrar la tabla de rutas

# route -n
# netstat -r (universal en todos los *NIX)
Saber el PID de un proceso que esta bloqueando un dispositivo (por ejemplo el cdrom):

# fuser /mnt/cdrom
Cazando ficheros en el disco duro:

# find / -name *practicas* -print (distingue ente mayús. y minús.)
# find / -iname *practicas* -print (no distingue entre mayús. y minús.)
¿Cuanto ocupa un directorio?

# du -hs <directorio>
¿Cuál es el estado de mis sistemas de ficheros montados? ¿Están casi llenos?

# df -h
Listado de ficheros abiertos en el sistema por un proceso en concreto:

# lsof | grep <nombre de proceso>
Información detallada sobre un fichero o partición:

# stat <fichero>

# stat -f /dev/<partición>
Últimos usuarios logeados:

# last
Usuarios logeados actualmente en el sistema:

# users
# who
¿Con que usuario estoy logeado?

# whoami
Comprimir un directorio en un tar.gz o tar.bz2

$ tar cfvz fichero_destino.tar.gz <directorio>
$ tar cfvj fichero_destino.tar.bz2 <directorio>
5. Tareas automatizadas con Cron
Cron es una utilidad de sistema que sirve para lanzar procesos con una periodicidad determinada,
como por ejemplo copias de seguridad u otro tipo de procesos que deben ser lanzados de forma
desatendida.
El paquete Cron provee dos utilidades, el demonio cron propiamente dicho y el editor de tareas,
crontab, que es la herramienta que más nos interesa.
Crontab (crontab -e) es un script que lanza nuestro editor favorito y abre un fichero donde se
almacenan todos los trabajos que se lanzan periódicamente. Este fichero tiene un formato
específico que veremos a continuación; una vez editado, crontab se encarga de integrarlo en el
sistema.
El formato de este fichero es el siguiente:
minutos horas dia mes diadelasemana comando
Minutos               Entre 0 y 59
Horas                 Entre 0 y 23
Día                   Entre 1 y 31
Mes                   Entre 1 y 12
Día de la semana      Entre 0 (Domingo) y 6 (Sábado)
Comando               El comando o comandos a ejecutar. Si no esta en
el PATH, hay que especificar toda su ruta
Ejemplo 1: ejecutar todos los días un script de copia de seguridad a las 7:00 de la mañana:

07***          /home/usuario/bin/copiaseguridad.sh
Ejemplo 2: ejecutar todos los primeros de mes un script de copia de seguridad a las 7:00 de la

mañana:
071**          /home/usuario/bin/copiaseguridad.sh
Ejemplo 3: ejecutar todos los viernes a las 21:30 un script de copia de seguridad:

30 21 * * 5 /home/usuario/bin/copiaseguridad.sh
Ejemplo 4: llamar al comando fetchmail cada 15 minutos:

0,15,30,45 * * * *            fetchmail
*/15 * * * *           fetchmail
Es muy importante especificar siempre la hora a la que queramos que se ejecuten los comandos,
por que si ponemos un * se ejecutarán una vez por hora en el caso de las horas, y una vez por
minuto en el caso de los minutos, etc.

6. Scripting
Muchas veces es útil programarnos nuestros propios guiones shell para automatizar tareas y
ahorrarnos trabajo. En ese apartado sólo vamos a mostraros el código de unos cuantos scripts que
ayudan en el día a día a algunos administradores socios de kleenux. Sin embargo, ya que os
pueden surgir muchas dudas, os recomendamos que visitéis y descarguéis la documentación que
se entregó en uno de los talleres del año pasado de kleenux, los cuales son una buena referencia
para empezar a programar en shell.
Documentación Taller Shell: http://blackshell.usebox.net/pub/shell/taller_sh/

backup.sh
Shell script sencillo que realiza una copia de seguridad de los directorios especificados.
#!/bin/sh
## backup.sh
## Realiza un backup de los directorios especificados indicando la fecha
## del backup
# IMPORTANTE: no añadir las barras al final
DIRS=”/var/www /var/log /home”
BASE=”/mnt/bakcup”
for i in $DIRS; do
tar cfvj $BASE/$(echo $i | sed ‘s/\///g’)-$(date ‘+%d-%m-%Y’).tar.bz2 $i
done
## EOF
kernel_mirror.sh
Hace un mirror de la última versión del kernel de linux.
Emplea:
$ finger @finger.kernel.org
[finger.kernel.org/204.152.191.37]
The latest stable version of the Linux kernel is:                            2.6.11.7
The latest prepatch for the stable Linux kernel tree is:                     2.6.12-rc2
The latest 2.4 version of the Linux kernel is:                               2.4.30


… para obtener la versión del último kernel estable.
Compara con la última versión que se descargó, y sino coincide, se baja la nueva del mirror de
rediris.
#!/bin/sh
# Script para hacer replica del ultimo kernel de linux con wget
#
# Uso: ejecutar en cron
#
# Juan J. Martinez <reidrac@blackshell.usebox.net>
# donde van a ir lo ficheros
DESTINATION=”/var/ftp/pub/Linux/kernel/”
# obtener la version larga del ultimo kernel
LATEST=`finger @finger.kernel.org | awk \
‘ /latest\ stable/ { print $10 }’`

# base del mirror en rediris
BASE=”ftp://ftp.rediris.es/pub/Linux/kernel/”
# version corta
VERSION=”v`echo $LATEST | cut -d. -f-2`”
# nos situamos en el destino
cd $DESTINATION
# para que en la primera vez que se usa no de error el cat
touch 00CURRENT
# ultima version descargada
CURRENT=`cat 00CURRENT`
# tenemos el ultimo?
if [ “X$LATEST” != “X$CURRENT” ]; then
# bajamos los cambios y los fuentes
wget -q -N $BASE/$VERSION/ChangeLog-$LATEST
wget -q -N $BASE/$VERSION/linux-$LATEST.tar.*
# actualizamos y renovamos el LEEME
echo $LATEST > 00CURRENT
echo “La ultima version estable del kernel es: $LATEST\n” \
> LEEME.mirror
date >> LEEME.mirror
# este mensaje se enviara por cron al admin
echo “Mirror del kernel Linux actualizado de $CURRENT a $LATEST”
fi
# EOF
mailCS.sh
Todos los *.rar que están en una determinada carpeta, son las copias de seguridad volcadas por
los usuarios.
Si la fecha de alguno de estos << rar >> es anterior a 10 días, se le comunica al usuario que debe
realizar la copia.
El usuario es avisado por email interno si es avisable, esto es, si no es de la gerencia que les sabe
muy mal que les avisemos, de ahí el fichero $FICH_AVISO.
#!/bin/sh
# mailCS.sh            mcm.artenvas.sep2004
# ——————————————-
# recordatorio de los usuarios que no hacen copia
# de seguridad
# ——————————————-
COPIA_DIR=/home/copiaseg/usr
FICH_AVISO=/root/bin/userAvisos.txt
DOMINIO=red
EMAIL_ADMIN=mariano@$DOMINIO
F_TMP=/tmp/tmp_$(date +%s)
tmax=10
function enviaMail()
{
cat <<FIN | mail -s “Aviso de copia” $1@$DOMINIO

Estimad@ $1:
Te informo que llevas [$2] dias sin hacer la copia.
Recomendamos hacerla cada semana.

Sin otro particular, un saludo
Dpto Informatica.
FIN
}
# — Inicia
touch $F_TMP
th=$(date +%s)
cd $COPIA_DIR
# — Iteramos por cada .rar
for frar in $(ls *.rar); do
tdif=$((($th-$(date -r $frar +%s))/(24*60*60)))
swtdif=$((tdif<$tmax))
# si la ultima copia esta en el intervalo –> salta
if [ $swtdif -ne 0 ]; then
shift
continue
fi
# si el usuario no existe –> salta
usuario=$(cat $FICH_AVISO | grep $frar | cut -f1 -d”:”)
if [ -z $usuario ]; then
shift
continue
fi
printf “%s\t– %d\n” $usuario $tdif >> $F_TMP
enviaMail $usuario $tdif
shift
done
# — envio de resumen (y borrado)
cat $F_TMP | mail -s “Los tardones de la copia” $EMAIL_ADMIN
rm $F_TMP 2>/dev/null
# — fin —
kill-user.sh
Mata todos los procesos del usuario pasado como parámetro.
#!/bin/sh
if [ $# -lt 1 ]; then
echo $0 user [SIGNAL]
exit
fi
SIGNAL=”TERM”
if [ $# -eq 2 ]; then
SIGNAL=$2
fi
PS=$(ps aU $1 2> /dev/null)
if [ $? -eq 1 ]; then
echo nothing to kill

exit
fi
for PID in $(echo “$PS” | awk ‘$1!=”PID” { print $1 }’); do
kill -$SIGNAL $PID 2> /dev/null
done
7. SSH: administración remota
SSH (Secure Shell) es un programa de login remoto que permite una transmisión segura de
cualquier tipo de datos: passwords, sesión de login, ficheros, sesión X remota, comandos de
administración, etc. Su seguridad estriba en el uso de criptografía fuerte de manera que toda la
comunicación es encriptada y autentificada de forma transparente para el usuario. Es un claro y
sencillo sustituto de los típicos comandos “r” de BSD (rlogin, rsh, rcp), telnet, ftp e incluso de
cualquier conexión TCP.
SSH sin contraseña
Algunas veces tenemos que logearnos muchas veces a lo largo del día en una misma máquina,
por lo que introducir nuestra contraseña cada vez puede llegar a ser un engorro. Somos unos ti@s
con suerte y el diseño de autentificación de openSSH nos va a ayudar a tener que olvidarnos de
nuestra contraseña!!
Para poder entrar en nuestra máquina tendremos que crear un par de claves y exportar la clave
pública de cada una de estas a nuestro host destino.
Generamos una clave rsa sin introducir ninguna contraseña:
enzo:~ josefu$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/josefu/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/josefu/.ssh/id_rsa.
Your public key has been saved in /Users/josefu/.ssh/id_rsa.pub.
The key fingerprint is:
e6:14:5c:f8:c5:92:b6:6b:ff:19:15:00:97:15:15:44 josefu@enzo.local
Hacemos los mismo para generar una clave dsa:
enzo:~ josefu$ ssh-keygen -t dsa
Generating public/private dsa key pair.
Enter file in which to save the key (/Users/josefu/.ssh/id_dsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/josefu/.ssh/id_dsa.
Your public key has been saved in /Users/josefu/.ssh/id_dsa.pub.
The key fingerprint is:
07:57:be:a6:8a:5b:a4:b6:7f:05:e8:1c:49:df:d5:32 josefu@enzo.local
Una vez completada la generación de las claves, las unimos en un mismo fichero llamado
authorized_keys2 y lo copiamos a través de un método seguro al directorio personal de
configuración del ssh en la máquina remota:
enzo:~ josefu$ cat .ssh/id_dsa.pub > authorized_keys2
enzo:~ josefu$ cat .ssh/id_rsa.pub >> authorized_keys2
enzo:~ josefu$ scp authorized_keys2 <máquina remota>:~/.ssh/
En estos momentos ya podemos entrar a nuestro servidor remoto sin tener que introducir ninguna
contraseña.

Exportar X’s
Si deseamos utilizar una aplicación de un ordenador remoto o de un PC que no tenga monitor,
tenemos una manera bastante simple de exportar dicha aplicación a nuestra computadora,
además, tendremos toda la sesión cifrada, obteniendo una mayor privacidad. Para ello tan sólo
necesitamos tener la opción X11Forwarding a yes en el archivo de configuración del demonio
ssh (/etc/ssh/sshd_config) de nuestro servidor remoto. Reiniciaremos el servicio ssh y ya
podremos ejecutar las aplicaciones en la máquina remota y obtendremos la salida en nuestro PC.
Para activar el X11Forwarding en nuestro cliente deberemos utilizar el parámetro -X como en el
siguiente ejemplo:
# ssh -X -l <usuario> <ip de la máquina remota>
Una vez dentro, podremos ejecutar cualquier aplicación gráfica, obteniendo la salida en nuestro
PC.
Túneles cifrados con SSH
Supongamos que queremos conectarnos a un servidor de correo, o que simplemente queremos
navegar, pero la parte de la red que tenemos más cerca es insegura. Por ejemplo, nos estamos
conectando mediante IEEE 802.11b (Wireless LAN) y no terminamos de fiarnos del WEP (Wired
Equivalent Privacy). O nos conectamos con un ISP cualquiera, o desde la Universidad, pero
nuestra paranoia nos hace pensar que la seguridad tradicional (casi nula) no es suficiente.
Supongamos también que tenemos acceso mediante SSH a una máquina de confianza, una
máquina en una parte “segura” de la red, o por lo menos más segura que la parte que nos
preocupa. Puede ser la máquina a la que nos queremos conectar para leer el correo, o el proxy
que usamos para navegar, o la máquina que hace de gateway entre la red inalámbrica y la red
“alámbrica”….
En ese caso, podemos tender un “puente”, o mejor dicho, un “túnel” mediante SSH entre nuestra
máquina y la máquina “segura”, salvando los peligros de la parte insegura de la red. En cierta
manera, conseguiremos “acercarnos” a la máquina segura.
Como normalmente haremos los túneles como usuarios normales, tenemos que tener en cuenta
que el puerto que utilizaremos en nuestro máquina deberá ser mayor al 1024 para que todo
funcione sin problemas de permisos.
Para poder usar esta funcionalidad del protocolo SSH tendremos que utilizar el parámetro -L al
ejecutar nuestro cliente SSH. Veamos el ejemplo general:
$ ssh -L <puerto local>:<máquina remota>:<puerto remoto> <máquina segura>
Ahora imaginemos que queremos conectarnos a nuestra máquina segura que tiene la IP
192.168.1.1 y que tiene un proxy web no accesible por la red insegura que escucha en el puerto
3128. La forma de realizar el túnel sería la siguiente:
$ ssh -L 13128:127.0.0.1:3128 192.168.1.1
Con esto conseguiríamos un túnel cifrado que empezaría en nuestra máquina (127.0.0.1) y que
estaría escuchando en un puerto elevado (13128) y que acabaría en la máquina segura
(192.168.1.1) en el puerto donde esta escuchando el proxy web (3128); así sólo nos quedaría
configurar nuestro navegador web para que utilizase el proxy ubicado en la IP 127.0.0.1 y puerto
13128.
Otro buen ejemplo sería utilizar un túnel cifrado en la red wifi para poder bajarnos nuestro correo
por pop3 hasta nuestro ordenador sin que nadie de la red inalámbrica pudiese ver que estamos
haciendo, el ejemplo sería el siguiente:
$ ssh -L 10110:pop.miisp.com:110 192.168.1.1
Configuraríamos nuestro cliente pop3 para que recogiese el correo del servidor ubicado de nuevo

en nuestra misma máquina, escuchando en el puerto 10110.
8. Gestión de software en Ubuntu
sources.list
El archivo /etc/apt/sources.list establece las fuentes de paquetes desde las que se instalará el
software de nuestra distribución.
Ubuntu, al estar basada en Debian, tiene una forma de desarrollo parecida a ésta. Se basa en dos
ramas de desarrollo, la llamada versión estable (en estos momentos Hoary) y la próxima revisión
de la distribución (Breezy). A la hora de configurar nuestro sources.list, podremos decidir de que
rama de la distribución actualizaremos e instalaremos nuestros paquetes. Cómo la lógica indica,
para uso normal, utilizaremos la versión estable de la distribución.
Un ejemplo de sources.list:
# Repositorio binario
deb http://us.archive.ubuntu.com/ubuntu hoary main restricted
# Repositorio de fuentes
deb-src http://us.archive.ubuntu.com/ubuntu hoary main restricted
# Repositorio local
deb file:/home/josefu/mirror/ubuntu hoary main restricted
# Repositorio ubicado en un cdrom
deb cdrom:[Ubuntu 4.10 _Warty Warthog_ – Preview i386 Binary-1 (20041020)]/
warty main restricted
Como podemos observar, las líneas del sources.list se desglosan de la siguiente manera:
deb o deb-src indica un repositorio de paquetes binarios o paquetes de código fuente

respectivamente.
http://, ftp://, file:, cdrom: son los más comunes e indican el protocolo o el tipo de origen del

repositorio.
<ruta al repositorio>, que puede ser un url o una ruta en el sistema de ficheros.

hoary se refiere a la rama de la distribución de la que se actualizarán los paquetes.

main, restricted son subapartados dentro de la distribución que se usan para diferenciar los

paquetes contenidos en ellos por motivos legales (licencias) o problemas de distribución.
Además de todos estos tipos de repositorios, en Ubuntu (y en Debian) existen unos repositorios
especiales, los denominados security:
deb http://security.ubuntu.com/ubuntu hoary-security universe
deb-src http://security.ubuntu.com/ubuntu hoary-security universe
Estos repositorios tienen la peculiaridad de que sólo contienen actualizaciones de seguridad de la
distribución.
apt
apt es el software encargado gestionar el software en las distribuciones basadas en Debian como
Ubuntu. Ahora veremos algunas operaciones básicas con apt:
Buscar un paquete: apt-cache search <paquete>

Mostrar información de un paquete: apt-cache show <paquete>

Mostrar las dependencias de un paquete: apt-cache depends <paquete>

Instalar un paquete: apt-get install <paquete>

Desinstalar un paquete: apt-get remove <paquete>

Desinstalar un paquete borrando todo su contenido del disco duro: apt-get –purge remove

<paquete>
Actualizar la lista de paquetes: apt-get update

Actualizar los paquetes de los que exista versión nueva: apt-get upgrade

Actualizar los paquetes de los que exista versión nueva y las bibliotecas de las que dependen

si hay versión nueva: apt-get dist-upgrade
dpkg
Hasta ahora hemos visto las utilidades apt para instalar y desinstalar software, no obstante, éstas
no son las que realmente se encargan de instalar el software en nuestro sistema. El comando que
realiza dicha acción es dpkg y también tiene algunas opciones que nos pueden ayudar a
solucionar problemas eventuales en los que apt no es capaz de solucionarnos la papeleta:
Instalar un paquete .deb: dpkg -i <paquete>.deb

Desinstalar un paquete .deb: dpkg -r <paquete>

Listar los paquetes instalados: dpkg -l

Archivos pertenecientes a un paquete: dpkg -L <paquete>

Paquete al que pertenece un fichero: dpkg -S <fichero>

Intenta arreglar un sistema con dependencias actualmente rotas: apt-get install -f

Compilando aplicaciones con apt
Existen programas que debido a su licencia, no esta permitida su redistribución en forma de
binario. Un ejemplo típico es el lector de correo en consola pine, para este tipo de programas,
podemos compilarlos de forma totalmente automatizada, obteniendo un paquete .deb que
posteriormente podremos instalar mediando dpkg, conservando el control de los paquetes
instalados en nuestro sistema.
Para compilar el pine necesitaremos una línea deb-src en nuestro sources.list, que como hemos
comentado anteriormente, nos proporciona un listado de los fuentes disponibles para compilar.
El primer paso consiste en resolver las dependencias de nuestro paquete, para lo cual
ejecutaremos el siguiente comando:
# apt-get build-dep pine
Una vez instalados todos los paquetes necesarios para la compilación de pine, lanzaremos la
descarga de los fuentes y la compilación de los mismos con:
# apt-get source –compile pine
Observaremos como apt nos hace todo el trabajo bajando las fuentes de pine y a continuación
lanzando la compilación de las mismas. Una vez finalizado el proceso podremos instalar los
paquetes generados con dpkg:
# dpkg -i *.deb
Compilación de módulos y aplicaciones
De vez en cuando nos encontramos con el problema de compilar una aplicación (o módulo del
kernel) que no esta disponible como paquete precompilado en nuestra distribución. En estos
casos es necesario compilar nuestros binarios, lo cual no suele ser demasiado complicado ya que

casi siempre tendremos algún fichero README o INSTALL en los fuentes de nuestra
aplicación/módulo a compilar. Es importante siempre leer todos los archivos de ayuda que
vengan con las fuentes para saber las dependencias del software y así buscarlas e instalarlas en
nuestra distribución.
Como ejemplo, vamos a compilar el módulo para una tarjeta wireless para la cuál, inicialmente,
no existe módulo precompilado para nuestra distribución/versión del kernel. Vamos a utilizar las
fuentes de las tarjetas basadas en el chip ipw2200 que incorporan la mayoría de los portátiles
actuales basados en la tecnología centrino.
Antes de empezar, necesitaremos tener nuestro entorno de trabajo preparado para la compilación
de dicho módulo; para ello necesitaremos las cabeceras del kernel que tengamos instalado y las
herramientas básicas de compilación. Como estamos trabajando sobre la distribución Ubuntu, los
pasos serían los siguientes:
# sudo apt-get install build-essential linux-headers-`uname -r`
Una vez instalado, tendremos en /usr/src las cabeceras de nuestro kernel y las herramientas de
compilación disponibles.
Ahora tan sólo nos falta descargar las fuentes del driver y las descomprimiremos en /usr/src
/usr/src # wget http://ovh.dl.sourceforge.net/sourceforge/ipw2200/ipw2200-
<version>.tgz
/usr/src # tar xfvz ipw2200-<version>.tgz
/usr/src # cd ipw2200-<version>
Luego sólo nos falta ejecutar lo siguiente para compilar el módulo e instalarlo en nuestro
sistema:
/usr/src/ipw2200-<version> # make
/usr/src/ipw2200-<version> # make install
Ahora vamos a compilar una aplicación desde las fuentes, como ejemplo, vamos a usar el cliente
de no-ip.com para obtener un dominio con nuestra ip dinámica. Los pasos a seguir son
prácticamente los mismos que en la compilación del módulo, no obstante, muchos paquetes
suelen incorporar un script llamado config o configure que debe ser ejecutado antes del make y
make install para comprobar que todas las dependencias estén cumplidas y no falle al compilar.
En este caso en particular no existe dicho script ya que es un programa muy sencillo.
A. Documentación adicional
Manual grub: http://www.linux.cu/manual/grub/grub.es.html

Bulma, Port Forwarding con SSH: http://bulma.net/body.phtml?nIdNoticia=1147

APT HOWTO: http://www.debian.org/doc/user-manuals#apt-howto

Linuca, Tareas automatizadas con Cron: http://linuca.org/body.phtml?nIdNoticia=256

Asociación de Usuarios de Software Libre de Elche, Kleenux: http://www.kleenux.org/

Listas de correo de kleenux: http://listas.kleenux.org/

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: