[Debian-Sarge] Túnel NFS sobre SSH

Última actualización: 27-09-2006 @ ~21:40

Razón: Se añadieron puertos fijos para el servidor nfs para facilitar la vida :)

Bienvenido

El objetivo de este cómo es construir un servidor NFS que funcione en un túnel SSH. De esta manera, todo el tráfico entre tus hosts y el servidor de archivos está cifrado y, por lo tanto, es más seguro :)

Normalmente deberías ingresar una contraseña cada vez que intentas establecer una conexión SSH, pero dado que podríamos estar montando al inicio, utilizaremos ssh-keygen para crear un par de claves para que podamos iniciar sesión sin ingresar una contraseña. Sin embargo, limitaremos esa sesión de inicio de sesión a ejecutar solo 1 comando ;)

Usaremos una nueva instalación limpia de Debian Sarge para comenzar.

En este cómo usaré el dominio ficticio “linux.lan”.

Instalando Software

Comenzaremos con el servidor NFS.

apt-get -y install nfs-kernel-server

Primero configúralo para que se ejecute en puertos fijos, esto hará que construir un firewall sea mucho más fácil, pero igualmente importante, ayuda en montajes de clientes más simples.

echo “STATDOPTS=–port 2231” > /etc/default/nfs-common
echo “options lockd nlm_udpport=2232 nlm_tcpport=2232” >> /etc/modules.conf
echo “RPCNFSDCOUNT=8 RPCMOUNTDOPTS=’-p 2233’” > /etc/default/nfs-kernel-server

Eso es todo, ahora podemos usar el puerto 2233 más adelante cuando montemos los recursos :) verifica si funcionó con rpcinfo -p. Si nlockmgr aún usa puertos aleatorios, es una configuración compilada. Configura esto en grub/lilo como parámetros del kernel:

“lockd.udpport=2232 lockd.tcpport=2232”.

Crea un nuevo usuario llamado sleeper para usar en la configuración del túnel ssh desde otros hosts. Generaremos una clave para esta cuenta para que puedas iniciar sesión con un archivo de clave en lugar de escribir tu contraseña cada vez. La cuenta también estará restringida a ejecutar ‘sleep’ de esta manera. Otros comandos simplemente fallarán.

adduser sleeper
su sleeper

Ahora cambia a un cliente que usará nuestro servidor de archivos.

Primero necesitamos una clave:

ssh-keygen -t rsa -b 2048

(utiliza los valores predeterminados y SIN frase de contraseña!)

Ahora copia el archivo .pub al directorio home de sleeper en el servidor:

scp -P 12345 ~/.ssh/id_rsa.pub [email protected]:~/

Ahora de vuelta al servidor: Como el usuario ‘sleeper’ necesitamos configurar/instalar la clave:

mkdir ~/.ssh
cd ~/.ssh
mv ../id_rsa.pub ./id_rsa.pub
cat id_rsa.pub >> authorized_keys
chmod 600 authorized_keys

Agrega esto al principio de authorized_keys (antes de ssh-rsa […]):

client="client.linux.lan",command="/bin/sleep 600d"

sustituye “client” con el nombre de host correcto de tu cliente, o usa números ip.

(pero asegúrate de que cada entrada permanezca en 1 línea!)

Cada cliente que necesite acceso al servidor de archivos necesita almacenar sus datos de seguridad (del archivo id_rsa.pub) en el archivo authorized_keys, por lo que deberías repetir esto para cada host.

Montando NFS sobre SSH en tus clientes

Emite estos comandos para iniciar los túneles para nfs y mountd:

(sintaxis: ssh -f -c cifrado -L puerto_local:nfsserver:nfsport -l nombre_usuario nfsserver comando_remoto)

También ten en cuenta que el número de puerto para mountd es diferente con cada reinicio del servidor NFS… Ten eso en cuenta.

ssh -f -i /root/.ssh/id_rsa -c blowfish -L 61001:10.0.0.241:2049 -l sleeper 10.0.0.241 sleep 600d
ssh -f -i /root/.ssh/id_rsa -c blowfish -L 62001:10.0.0.241:2233 -l sleeper 10.0.0.241 sleep 600d

Esto crea una conexión que permanecerá activa durante casi 2 años… :)

Ahora edita tu fstab y monta:

echo “localhost:/export/data /mnt nfs tcp,rsize=8192,wsize=8192,intr,rw,bg,nosuid,port=61001,mountport=62001,noauto” >> /etc/fstab mount /mnt

Por supuesto, necesitamos algunas carpetas montables (recursos) definidas en el servidor NFS:

mkdir /export
mkdir /export/data
mkdir /export/www-virtual
mkdir /export/www-conf
mkdir /export/mail-virtual
mkdir /export/mail-conf

Agrégalas a /etc/exports:

/home/export/data 10.0.0.241(rw,root_squash,sync)

¿Notas que la dirección ip es el propio servidor nfs? Es porque las montarás desde localhost cuando hayas establecido el túnel ssh.

Algunas configuraciones de seguridad ya que no queremos que nadie fuera de nuestra red acceda al servidor: echo “portmap: ALL” > /etc/hosts.deny
echo “portmap: 10.0.0.0/255.255.255.0” > /etc/hosts.allow

Reinicia NFS: /etc/init.d/nfs-kernel-server restart

¡Eso es todo! Ahora puedes montar el sistema de archivos en tus clientes sin necesidad de proporcionar una contraseña. Y, por supuesto, todo el tráfico estará cifrado :)