Servidor SFTP Enjaulado

Improvisa :: Informática :: Servidor SFTP EnjauladoBueno en este nuevo manual, howto, guia o como os guste llamarlo os enseñaremos a crear un servidor FTP seguro­ (SFTP­) y SCP. Sustituyendo de esta forma al obsoleto FTP, donde las contraseñas viajaban en claro por la red. El FTP como tal sigue siendo un protocolo de los mejorcito para la descarga de archivos, es decir sin que podamos escribir en esos directorios.

Con este nuevo servidor conseguiremos, a efectos del usuario, lo mismo que se conseguía con el servicio FTP pero de una forma muchísimo más segura.

Además para salvaguardar las configuraciones de nuestro equipo así como archivos que nos son necesarios mostrar a los usuarios que entran en el servicio, enjaularemos a estos usuarios en un entorno donde lo único que podrán hacer será gestionar los archivos que su­ben, es decir les permitiremos borrarlos, crearlos moverlos renombrarlos y poquito más.

Aprenderemos a montar el servidor sftp y scp, os enseñaremos el funcionamiento del sistema de ficheros de GNU/Linux y crearemos una estructura de directorios algo complicada para que aprendamos a realizar cualquier estructura de directorios y compartirla por SFTP y SCP.
­

Sin más nos pondremos manos a la obra……..

Para que nos quede un poco más claro lo que es una jaula intentaré explicaros de una forma sencilla su funcionamiento. Una jaula es una especie de interfaz completamente ajustable para los usuarios que queramos dar acceso. Se trata de dar al usuario que tenemos configurado para entrar en la jaula un pequeño sistema operativo con los ­comandos que queramos que ejecute. Si por ejemplo queremos que ejecute ntpdate, tendremos que pasar el binario ntpdate y sus dependencias a la jaula. Crearemos un conjunto de archivos exactamente igual que en nuestro Debian pero solo con lo que queramos que ejecute el usuario enjaulado. Además conseguiremos que no se mueva por los directorios que no queramos.

En nuestro ejemplo lo que queremos es enjaular a los usuarios en su home y que tengan permisos para utilizar SCP y SFTP en sus directorios respectivos, podrán mover, borrar, copiar siempre y cuando tengan permisos sobre los archivos.

La jaula teóricamente es muy fácil de montar, simplemente deberemos añadir un nuevo shell al usuario que entra, este shell será únicamente una llamada por chroot al directorio donde hemos creado la jaula. Dentro de la jaula deberemos tener el nuevo shell para ese mismo usuario, es decir existirán 2 /etc/passwd uno el autentico del sistema, que será donde llamaremos al shell falso (el que crearemos) y otro el de la jaula el cual situaremos, por ejemplo, en /datos/jaula/etc/passwd. Al hacer el chroot sobre /datos/jaula el usuario accederá al nuevo /etc/passwd enjaulado y allí le indicaremos que su shell es /bin/bash para que de esta forma pueda ejecutar lo que situemos en el nuevo /bin. Lo mejor es verlo en un ejemplo……….

En nuestro ejemplo, lo que realizaremos será una jaula para 2 usuarios, uno de ellos llamado juanmi y el otro angel, cada uno de ellos tendrá un home diferente y juanmi podrá escribir en el home de angel pero no al contrario. Crearemos la jaula en /datos/jaula. Los usuarios podrán borrar archivos de su propiedad o de la de su grupo, pero no los directorios "madre", directorios que por necesidades del ejemplo no pueden ser borrados.

Manos a la obra:

Como siempre el servidor los realizamos en Debian estable a día 3 de octubre del 2008, Debian Etch 4.0r4a.

Instalación de paquetes necesarios:

Para la creación de la jaula solo necesitaremos los paquetes sudo y ssh los cuales instalaremos de la siguiente forma:

root@jaula:~# apt-get install ssh sudo

Creación de la Jaula de forma Semi-Automatica:

Existen dos formás de crear la jaula, una automáticamente, con el script creado por Wolfgang Fuschlberger, funciona a la perfección en sistemás operativos  Debian, Red Hat, Fedora y Suse. El script es muy facilito de usar.

Si queréis probar con el script y luego realizarlo de una forma manual, la utilización del script os dejará clara la creación de la jaula ya que podréis mirar que ha hecho.

La utilización del script es bien fácil, debemos descargarlo de aquí o de aquí (lo dejo en Improvisa por si se extravía).

root@jaula:~# cd /usr/src/
root@jaula:/usr/src# wget http://www.fuschlberger.net/programs/ssh-scp-sftp-chroot-jail/make_chroot_jail.sh
root@jaula:/usr/src# chmod a x make_chroot_jail.sh

Bastará con decirle ./make_chroot_jail.sh y el nos dirá las opciones que podemos utilizar

root@jaula:/usr/src# ./make_chroot_jail.sh

USAGE:
Create new chrooted account or
add existing User to chroot-jail:
-> /usr/src/make_chroot_jail.sh username

or specify $SHELL and path where the jail should be located:
-> /usr/src/make_chroot_jail.sh username [/path/to/chroot-shell [/path/to/jail]]
Default shell       = /bin/chroot-shell
Default chroot-path = /home/jail
————————————————————-

Updating files in the chroot-jail:
-> /usr/src/make_chroot_jail.sh update [/path/to/chroot-shell [/path/to/jail]]
————————————————————-

To uninstall:
 # userdel $USER
 # rm -rf /home/jail
 (this deletes all Users’ files!)
 # rm -f /bin/chroot-shell
 manually delete the User’s line from /etc/sudoers

Yo utilizaré lo siguiente para creara la jaula para el usuario juanmi, el shell por defecto y el path de la jaula /datos/jaula

root@jaula:/usr/src# ./make_chroot_jail.sh juanmi /bin/chroot-shell /datos/jaula

Nos irá pidiendo password para el usuario y no es la primera vez que ejecutamos el script nos preguntará si estamos añadiendo un segundo usuario y si es así debemos decirle que si, para que sobreescriba los archivos.

Deciros que para la creación del servidor SCP y SFTP nos bastará con la instalación del script, es decir que si queréis hacerlo manualmente será para aprender.

Creemos al segundo usuario:

root@jaula:/usr/src# ./make_chroot_jail.sh angel /bin/chroot-shell /datos/jaula

Debemos realizar ajustes al final, ahora os cuento como hacerlo de forma manual.

Creación de la Jaula de forma Manual:

Crearemos los directorios donde crearemos la jaula, en nuestro caso /datos/jaula:

root@jaula:~# mkdir -p /datos/jaula

Crearemos al primer usuario

root@jaula:~# adduser juanmi

Rellenad los datos que nos vaya pidiendo y crearemos al segundo usuario:

root@jaula:~# adduser angel

Contestad con los datos del usuario angel y pasemos a editar el archivo de configuración de los usuarios para decirle que shell deben ejecutar al entrar.

root@jaula:~# vi /etc/passwd

Nos encontraremos al final del archivo con algo así:

juanmi:x:1012:1025:,,,:/home/juanmi:/bin/bash
angel:x:1013:1026:,,,:/home/angel:/bin/bash

Y debemos dejarlo así:

juanmi:x:1012:1025::/datos/jaula/home/juanmi:/bin/chroot-shell
angel:x:1013:1026::/datos/jaula/home/angel:/bin/chroot-shell

Si os dais cuenta aquí esta donde configuramos los homes de los nuevos usuarios, diciéndole el de la jaula y que shell ejecutaran, en el caso del ejemplo utilizaremos /bin/chroot-shell el cual tendremos que crear:

root@jaula:~# vi /bin/chroot-shell

#!/bin/sh
/usr/bin/sudo /usr/sbin/chroot /datos/jaula /bin/su – $USER "$@"

root@jaula:~# chmod a x /bin/chroot-shell

Lo único que hace el script es ejecutar como el usuario que entra /bin/su – usuario sobre la jaula. y quedarse ahí.

Teniendo los usuarios creados y los grupos creados, se crean automáticamente al ejecutar adduser debemos crear la jaula con sus respectivos ficheros, proceso largo y tedioso ya que debemos ir uno a uno pasándolos a la jaula, de ahí la comodidad del script.

Ahora debemos ir ejecutando ldd para los binarios que vayamos necesitando meter, ldd nos listará las dependencias de los paquetes que le vamos diciendo y todas ellas debemos meterlas en la jaula a así como el binario:

root@jaula:~# ldd rm
        linux-gate.so.1 =>  (0xffffe000)
        libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7dd5000)
        /lib/ld-linux.so.2 (0xb7f0c000)

root@jaula:~# mkdir -p /datos/jaula/bin
root@jaula:~# mkdir -p /datos/jaula/dev
root@jaula:~# mkdir -p /datos/jaula/etc
root@jaula:~# mkdir -p /datos/jaula/home
root@jaula:~# mkdir -p /datos/jaula/lib
root@jaula:~# mkdir -p /datos/jaula/sbin
root@jaula:~# mkdir -p /datos/jaula/usr
root@jaula:~# mkdir -p /datos/jaula/lib/tls/i686/cmov
root@jaula:~# cp -p /lib/tls/i686/cmov/libc.so.6 /home/jaula/lib/tls/i686/cmov/libc.so.6
root@jaula:~# cp -p -P /lib/ld-linux.so.2 /home/jaula/lib/ld-linux.so.2

En este ejemplo solo he puesto la creación del directorio para el comando rm y sus dependencias, pero debéis ejecutarlo para cada uno de los archivo que debemos meter en la jaula, los cuales son:

/bin/bash
/bin/cp
/usr/bin/dircolors
/bin/ls
/bin/mkdir
/bin/mv
/bin/rm
/bin/rmdir
/bin/sh
/bin/su
/usr/bin/groups
/usr/bin/id
/usr/bin/rsync
/usr/bin/ssh
/usr/bin/scp
/sbin/unix_chkpwd

Una vez hemos creado todo pasemos a configurar los permisos de directorio para cada usuario.

En nuestro ejemplo crearemos diferentes homes para cada usuario, para juanmi crearemos el home Fotografias y para angel crearemos el home Videos. Los que hayáis utilizado el script automático debéis realizar los cambios cambios correspondientes en /etc/passwd y en /datos/jaula/etc/passwd ya que el script crea directamente el /datos/jaula/home/NOMBRE_USUARIO pero como lo que queremos es cambiarla pues debemos editarlo.

root@jaula:~# mkdir /datos/jaula/home/Fotografias
root@jaula:~# mkdir /datos/jaula/home/Videos

root@jaula:~# vi /etc/passwd

juanmi:x:1012:1025::/datos/jaula/home/Fotografias:/bin/chroot-shell
angel:x:1013:1026::/datos/jaula/home/Videos:/bin/chroot-shell

Ahora el de la jaula

root@jaula:~# vi /datos/jaula/etc/passwd

juanmi:x:1012:1025::/home/Fotografias:/bin/bash
angel:x:1013:1026::/home/Videos:/bin/bash

Todavía no borraremos los que nos ha creado el script, necesitamos copiar antes los archivos de uno de los homes a la carpeta comun que nos crearemos, los utilizaremos en los pasos siguientes:

root@jaula:~# mkdir /datos/jaula/comun
root@jaula:~# cp /datos/jaula/home/juanmi/.b* /datos/jaula/comun

Ahora si, ya podemos borrar los homes que nos ha creado el script.

root@jaula:~# rm -r /datos/jaula/home/juanmi/
root@jaula:~# rm -r /datos/jaula/home/angel/

Una vez creados los directorios, homes de cada usuario debemos añadir grupos para que de esa forma distintos usuarios puedan entrar en el home de otro usuario. Crearemos 2 nuevos grupos uno lo llamaremos gfotografias y otro gvideos

root@jaula:~# addgroup gfotografias
Adding group `gfotografias’ (GID 1028) …
Hecho.

root@jaula:~# addgroup gvideos
Adding group `gvideos’ (GID 1029) …
Hecho.

Añadidos los grupos debemos añadir los usuarios a los grupos, en nuestro ejemplo es juanmi el que puede escribir en el home de angel, es decir juanmi puede escribir en el directorio Fotorafias y Videos y angel solo podrá escribir en Videos, para ello añadiremos a juanmi al grupo gfotografias y gvideos y a angel solamente a gvideos.

root@jaula:~# addgroup juanmi gfotografias
Adding user `juanmi’ to group `gfotografias’ …
Hecho.

root@jaula:~# addgroup juanmi gvideos
Adding user `juanmi’ to group `gvideos’ …
Hecho.

root@jaula:~# addgroup angel gvideos
Adding user `angel’ to group `gvideos’ …
Hecho.

Muy bien por ahora hemos creado los usuarios, los grupos y hemos añadido los usuarios a los grupos correspondientes, pero lo hemos hecho en el sistema y no en la jaula. Para ellos basta con editar los archivos /datos/jaula/etc/passwd y /datos/jaula/etc/group:

Con nuestro ejemplo debería quedarnos según lo dejo, los UID y GID son distintos en cada usuario, debéis mirar vuestro archivo /etc/passwd y según estén allí copiarlos al passwd enjaulado. Exactamente igual debemos hacer con el archivo /etc/group.

root@jaula:~# vi /datos/jaula/etc/passwd

root:x:0:0:root:/root:/bin/bash
juanmi:x:1012:1025::/home/Fotografias:/bin/bash
angel:x:1013:1026::/home/Videos:/bin/bash

root@jaula:~# vi /datos/jaula/etc/group
root:x:0:
users:x:100:
juanmi:x:1025:
angel:x:1026:
gfotografias:x:1028:juanmi
gvideos:x:1029:juanmi,angel

Una vez tenemos nuestros usuarios y grupos puestos en los archivos enjaulados debemos dar permisos a las carpetas, empezaremos dando permisos de ejecución, escritura y lectura al propietario y al grupo.

root@jaula:~# chmod 770 -R /datos/jaula/home/Fotografias
root@jaula:~# chmod 770 -R /datos/jaula/home/Videos

Ahora haremos propietario de los directorios a root y pertenecerán al grupo correspondiente:

root@jaula:~# chown root:gfotografias -R /datos/jaula/home/Fotografias
root@jaula:~# chown root:gvideos -R /datos/jaula/home/Videos

Perfecto, necesitamos que todo lo que se cree dentro de estos directorios herede el grupo propietario, esto se hace añadiendo el SGID al directorio.

root@jaula:~# chmod g s -R /datos/jaula/home/Fotografias
root@jaula:~# chmod g s -R /datos/jaula/home/Videos
root@jaula:~# ls -la

total 20
drwxr-xr-x  5 root root         4096 2008-10-03 00:31 .
drwxr-xr-x 10 root root         4096 2008-10-02 21:41 ..
drwxrws—  4 root gfotografias 4096 2008-10-02 21:45 Fotografias
drwxrws—  2 root gvideos      4096 2008-10-02 21:44 Videos

Daros cuenta de la "S" que ha añadido a los permisos de cada uno de los directorios.

Muy bien ahora debemos añadir el Sticky Bit T a los directorios para que jamás sean borrados, aunque lo intente el root o algún usuario del grupo, solamente se podrá borrar si previamente le quitamos el Sticky Bit. Esto solo lo deberíamos aplicar a cada uno de los homes de cada usuario.

root@jaula:~# chmod t /datos/jaula/home/Fotografias
root@jaula:~# chmod t /datos/jaula/home/Videos
root@jaula:~# ls -la

total 20
drwxr-xr-x  5 root root         4096 2008-10-03 00:31 .
drwxr-xr-x 10 root root         4096 2008-10-02 21:41 ..
drwxrws–T  4 root gfotografias 4096 2008-10-02 21:45 Fotografias
drwxrws–T  2 root gvideos      4096 2008-10-02 21:44 Videos

Perfecto ya tenemos casi todo para empezar a hacer pruebas. Lo único que nos queda es cambiar el umask con el que los usuarios crearán archivos dentro de la jaula. Por defecto la creación de archivos se hace con 644, es decir solo permitimos el borrado de los permisos al usuario propietario y no al grupo propietario, cosa que no nos interesa, debemos permitir al grupo hacer lo mismo que al usuario, es decir aplicar permisos 660 a todo lo que se cree en esas carpetas. Para ello debemos cambiar el profile de cada uno de los usuarios, yo como normalmente aplico lo mismo a cada usuario utilizo el directorio comun que cree unos pasos más arriba y hago links blandos a esos archivos, para solo modificar un archivo, aun así tu puedes ir modificando uno a uno si te viene mejor. El ejemplo es creando los links hacia la carpeta comun. Debemos hacerlo desde el home del usuario y con enlaces universales, es decir validos dentro de la jaula

root@jaula:~# cd /datos/jaula/home/Fotografias
jaula:/datos/jaula/home/Fotografias# ln -s ../../comun/.bashrc .bashrc
jaula:/datos/jaula/home/Fotografias# ln -s ../../comun/.bash_logout .bash_logout
jaula:/datos/jaula/home/Fotografias# ln -s ../../comun/.bash_profile .bash_profile
jaula:/datos/jaula/home/Fotografias# cd /datos/jaula/home/Videos
jaula:/datos/jaula/home/Videos# ln -s ../../comun/.bashrc .bashrc
jaula:/datos/jaula/home/Videos# ln -s ../../comun/.bash_logout .bash_logout
jaula:/datos/jaula/home/Videos# ln -s ../../comun/.bash_profile .bash_profile

Editemos el archivo comun donde cambiaremos el umask, es .bash_profile, buscad donde está comentada la umask 022 y cambiadla por umask 0006, os pongo como queda en DEBIAN, lo único que he hecho es cambiar la linea umask

root@jaula:~# vi /datos/jaula/comun/.bash_profile

# ~/.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 0006

# include .bashrc if it exists
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

# set PATH so it includes user’s private bin if it exists
if [ -d ~/bin ] ; then
    PATH=~/bin:"${PATH}"
fi

Aseguremonos que los tres archivos solo tienen permisos 644:

root@jaula:~# chmod 644 /datos/jaula/comun/.b*

Ya podéis empezar a hacer pruebas con el programita que más os guste, filezilla, winscp o cualquiera de ellos.

El ejemplo que he puesto es relativamente sencillo, solamente tiene 2 directorios y pocas restricciones, el que os planteo ahora es el que se me dio en realidad:

Usuarios:
Administrador
Maquetacion1
Maquetacion2
Maquetacion3
Maquetacion4
Redaccion1
Redaccion2
Redaccion3
Edicion
Video
Fotografia
Web

Directorios:
EMPRESA
    OTROS
        FOTOS
        VIDEOS
        WEB
    DATOS
        EMPLEA
        FOTOS
        GUIA
        UBR
PRIVADO

Permisos:
EMPRESA —> Todos
    OTROS —> Video, Fotografia, Web, Adinistrador
        FOTOS —> Fotografia, Administrador
        VIDEOS —> Video, Administrador
        WEB —> Web, Administrador
    DATOS —> Maquetacion1, Maquetacion2, Maquetacion3, Maquetacion4, Redaccion1, Redaccion2, Redaccion3, Edicion, Fotografia, Administrador
        EMPLEA —> Maquetacion1, Maquetacion3, Redaccion1, Redaccion2, Edicion, Administrador
        FOTOS —> Maquetacion1, Fotografia, Administrador
        GUIA —> Maquetacion1, Maquetacion2, Redaccion1, Redaccion3,
        UBR —> Maquetacion1, Maquetacion4, Administrador
PRIVADO —> Administrador

Grupos:
empresa
otros
fotosotros
videos
web
datos
emplea
fotosdatos
guia
ubr
privado

Directorios con Permisos:
EMPRESA —> drwxrws–T  4 root empresa
    OTROS —> drwxrws–T  4 root otros
        FOTOS —> drwxrws–T  4 root fotosotros
        VIDEOS —> drwxrws–T  4 root videos
        WEB —> drwxrws–T  4 root web
    DATOS —> drwxrws–T  4 root datos
        EMPLEA —> drwxrws–T  4 root emplea
        FOTOS —> drwxrws–T  4 root fotosdatos
        GUIA —> drwxrws–T  4 root guia
        UBR —> drwxrws–T  4 root ubr
PRIVADO —> drwxrws–T  4 root privado

Notas:

Si queremos que sólo un administrador, el que asignemos, pueda borrar los ficheros creados por los demás, debemos asignar como usuario propietario de los directorios a ese usuario y como grupo propietario al correspondiente a nuestro ejemplo.

Quedaría así:

EMPRESA —> drwxrws–T  4 Administrador empresa
    OTROS —> drwxrws–T  4 Administrador otros
        FOTOS —> drwxrws–T  4 Administrador fotosotros
        VIDEOS —> drwxrws–T  4 Administrador videos
        WEB —> drwxrws–T  4 Administrador web
    DATOS —> drwxrws–T  4 Administrador datos
        EMPLEA —> drwxrws–T  4 Administrador emplea
        FOTOS —> drwxrws–T  4 Administrador fotosdatos
        GUIA —> drwxrws–T  4 Administrador guia
        UBR —> drwxrws–T  4 Administrador ubr
PRIVADO —> drwxrws–T  4 Administrador privado

Os cuento esto porque con el Sticky Bit T no podran borrar los archivos nada más que los propietarios del fichero y los propietarios del directorio donde se encuentra.

Agradecimientos:

­Bueno espero que os valga y que hayáis aprendido, yo lo he hecho y me ha encantado pegarme con esto, cosa que no podría haber hecho sin mi gurú del linux Alfonso de MicroAlcarria 😉 Mil gracias como siempre. Cambien merece mi agradecimiento Wolfgang Fuschlberger por crear el script que quita muchísimo trabajo.

Print Friendly, PDF & Email
Comentarios
  • Juanmi dice:

    Enviada a:

    Autobombo.es

    Autobombeame.com

    Pegadle unos votitos chicos 😉

  • CeLSuM dice:

    Estupendo tio!!!

    Lo he testeado y funciona a la perfección… 😀

    Mi única duda es la siguiente:

    Me he creado dos cuentas una “peliculas” y otra “fotos”, y todo correcto, son excluyentes. Peeeeeeero mis datos no están en la /home/fotos/ ni en la /home/peliculas/, como tú bien sabes los tengo en /mnt/Backup/Fotos, el problema es otra vez de permisos intuyo ya que cuando intento crear el enlace simbólico dentro de “servidor:/datos/jaula/home/fotos/ ln -s /mnt/Backup/Fotos” lo crea pero no me deja acceder.

    Mi pregunta es ¿tengo que copiar todos los datos a la “nueva” home de fotos o puedo crear enlaces dentro de la “nueva” home a otras carpetas cualesquiera de mi disco duro?

    Muchas Gracias, una vez más…

  • Juanmi dice:

    La solución es crear la jaula en el sitio que tu quieras, para ello utiliza lo que dice la ayuda del script 😉

    Ahi va lo que suelta:

    USAGE:
    Create new chrooted account or
    add existing User to chroot-jail:
    -> /usr/src/make_chroot_jail.sh username

    or specify $SHELL and path where the jail should be located:
    -> /usr/src/make_chroot_jail.sh username [/path/to/chroot-shell [/path/to/jail]]
    Default shell = /bin/chroot-shell
    Default chroot-path = /home/jail
    ————————————————————-

    Updating files in the chroot-jail:
    -> /usr/src/make_chroot_jail.sh update [/path/to/chroot-shell [/path/to/jail]]
    ————————————————————-

    To uninstall:
    # userdel $USER
    # rm -rf /home/jail
    (this deletes all Users’ files!)
    # rm -f /bin/chroot-shell
    manually delete the User’s line from /etc/sudoers

  • iam33 dice:

    Procedimiento genial!! Muchas gracias!!!

    Una duda que facil que le haya surgido a mas de uno:

    Necesito que uno de los usuarios enjaulados ejecute un comando atraves del sudo, por lo que he hecho lo siguiente

    .-Copio el binario del sudo a la jaula y todas las librerias necesarias

    .-Edito el sudoers con la parametrizacion necesaria y lo copio

    tambien a la jaula.

    Pero al intentar ejecutar el comando con el usuario enjaulado no me reconoce dicho comando. Es necesario copiar todos los binarios y sus librerias a la ruta de la jaula aun cuando se ejecutan con sudo?

     

    Muchas gracias y un saludo.

  • Juanmi dice:

    Efectivamente debes copiar todo lo relaccinado con el comando que necesitas que ejecute ese usuario. Es decir la jaula tiene lo que tiene no hay mas, si necesitas que ejecute ifconfig por ejemplo, necesitaras copiar el binario y las librerias que necesite.

    Saludos y perdona latardanza estuve de vacaciones y he vuelto hoy 😉