Servidor SSH+CVS seguro (en chroot) en OpenBSD 4.1

Este documento es una adaptación para openbsd del manual de eldemonio.org para netbsd.

Ha sido provado con la versión 4.1 de OpenBSD y como cliente se ha utilizado OSX.

El documento puede ser copiado, modificado, redistribuido, con la única condicion de hacer mencion al autor y la url original del documento. http://www.forniol.cat/manuals/manual_openbsd_cvs_ssh_chroot.html

Configuraciones previas

Si partimos de una instalación limpia de openbsd 4.1 recomiendo instalar nano, un editor visual de consola, pero si os gusta vi u otro podeis omitir este paso.

      # echo "export PKG_PATH=ftp://ftp.rediris.es/pub/OpenBSD/4.1/packages/`machine -a`/" \
        >> /root/.profile
      # export PKG_PATH=ftp://ftp.rediris.es/pub/OpenBSD/4.1/packages/`machine -a`/
      # pkg_add -v nano-2.0.3.tgz

Primero vamos a cambiar el fichero fstab para que permita crear dispositivos en la partición /home donde vamos a instalar el chroot. Para ello le quitamos la opción nodev.

      # nano /etc/fstab

        /dev/wd0a / ffs rw 1 1
        /dev/wd0h /home ffs rw,nosuid 1 2
        /dev/wd0d /tmp ffs rw,nodev,nosuid 1 2
        /dev/wd0g /usr ffs rw,nodev 1 2
        /dev/wd0e /var ffs rw,nodev,nosuid 1 2

Aplicamos los cambios en la partición

      # umount /home
      # mount /home

Creando el entorno chroot

      # mkdir -p /home/chroot/cvs
      # cd /home/chroot/cvs
      # mkdir -p bin dev etc home/ricard lib libexec/auth sbin tmp var/empty
      # mkdir -p var/run var/chroot/sshd
      # ln -s . usr
      # chmod -R 555 home
      # chmod 1777 tmp

Como podéis ver, hemos hecho que el directorio usr sea un enlace al directorio raíz del chroot. Hacemos esto para simplificar la estructura. También hemos dado los permisos 1777 al directorio temporal y 555 al que utilizarán los usuarios como directorio personal.

Ahora copiamos algunos comandos y sus respectivas librerías

      # cd /home/chroot/cvs
      # cp /bin/ksh /bin/ls /bin/rm /bin/mkdir /bin/cp /bin/mv /bin/echo \
        /usr/bin/cvs /usr/bin/passwd /usr/bin/login bin
      # cp /sbin/nologin /usr/sbin/pwd_mkdb /usr/sbin/sshd sbin
      # cp /etc/master.passwd /etc/group etc
      # cp /usr/libexec/ld.so libexec
      # cp -rf /etc/ssh etc
      # cp /etc/login.conf etc
      # cp /usr/libexec/auth/login_passwd libexec/auth
      # cp `ldd bin/passwd sbin/sshd libexec/auth/login_passwd  | \
        grep -v -e 'libexec' -e 'bin' -e 'sbin'  -e 'Start' | awk '{print $7}'` lib

Creamos los dispositivos necesarios

      # cd /home/chroot/cvs/dev
      # /dev/MAKEDEV std pty0 random

Configurando los usuarios

Editamos los ficheros de grupos y usuarios y dejamos solo aquellos que nos interesan.

      # cd /home/chroot/cvs
      # nano etc/group
      
        wheel:*:0:root
        sshd:*:27:
        _shadow:*:65:
        nogroup:*:32766:
        nobody:*:32767:
        cvs:*:500:ricard

      # nano etc/master.passwd
      
        root:*:0:0::0:0:Administrador,,,:/root:/bin/ksh
        sshd:*:16:16::0:0:& pseudo-user:/var/chroot/sshd:/sbin/nologin
        nobody:*:32767:39::0:0:Unprivileged user:/nonexistent:/sbin/nologin
        ricard:*:1000:500::0:0:Ricard Forniol,,,:/home/ricard:/bin/ksh

Creamos las bases de datos de usuarios.

      # cd /home/chroot/cvs
      # /usr/sbin/pwd_mkdb -d /home/chroot/cvs/etc etc/master.passwd
      # /usr/sbin/pwd_mkdb -d /home/chroot/cvs/etc -p etc/master.passwd

Creamos el directorio de nuestro repositorio cvs.

      # cd /home/chroot/cvs
      # mkdir -p cvsroot
      # chown 1000:500 cvsroot
      # chmod 775 cvsroot

Probando el entorno chroot

      # chroot /home/chroot/cvs
      # passwd ricard
         Changing local password for ricard
         New password:
         Retype new password:
      # exit

Si no os da ningún error todo es correcto. De lo contrario aseguraos que la partición del chroot esté montada sin la opción nodev.

Configurando el servidor

Es el momento de configurar el servidor SSH para que funcione correctamente y no interfiera con otro posible servidor en la misma máquina. Es importante que generéis las claves del servidor en caso de que no existan aún:

      # cd /home/chroot/cvs/etc/ssh
      # /usr/bin/ssh-keygen -t rsa1 -b 1024 -f ssh_host_key -N ''
      # /usr/bin/ssh-keygen -t dsa -f ssh_host_dsa_key -N ''
      # /usr/bin/ssh-keygen -t rsa -f ssh_host_rsa_key -N ''

Ahora le cambiamos el puerto por defecto al servidor ssh enjaulado por el 11750 por ejemplo descomentando (quitamos #) Port 22 y ponemos 11750.

      # nano sshd_config

        Port 11750
        ...

Ejecutamos el servidor dentro de la jaula

# chroot /home/chroot/cvs /sbin/sshd

Configurando el cliente

Ahora es momento de configurar el cliente para que pueda acceder al servidor de un modo más sencillo. Para ello, editaremos el archivo ~/.ssh/config del usuario que haga de cliente en la máquina remota. Añadiremos las siguientes lineas al final del archivo.

      $ nano sshd_config

        Host miservidor.cvs.org
        Port 11750

Lo guardamos y nos intentamos conectar

      $ ssh ricard@miservidor.cvs.org

NOTA: Si no habéis configurado previamente una contraseña para el usuario no podréis acceder. Una vez dentro la podéis cambiar.

Iniciando el repositorio CVS

Bien, una vez configurado todo el SSH dentro del chroot, el funcionamiento de CVS es prácticamente automático. Configuraremos un par de variables e inicializaremos el repositorio CVS desde el cliente:

      $ export CVSROOT=:ext:ricard@miservidor.cvs.org:/cvsroot
      $ export CVS_RSH=ssh
      $ cvs init

NOTA: si queremos podemos poner las dos primeras linias en el ~/.profile o equivalente de nuestro usuario para que CVSROOT y CVS_RSH tengan siempre ese valor al iniciar sesión.

Aseguramos que todos los permisos estan correctos directorios 775, ficheros 664 y el propiertorio ricard y el grupo cvs.

      # cd /home/chroot/cvs/cvsroot
      # find . -type d -exec chown ricard:cvs {} \;
      # find . -type d -exec chmod 775 {} \;
      # find . -type f -exec chown ricard:cvs {} \;
      # find . -type f -exec chmod 664 {} \;

Para terminar

Para que el servidor ssh enjaulado se inice al arrancar añadimos al /etc/rc.local una linia.

      # echo "/usr/sbin/fchroot /home/chroot/cvs /sbin/sshd" >> /etc/rc.local

Con esto ya tenemos un servidor CVS listo para funcionar enjaulado. Es recomendable utilizar claves para la autentificación ya que así no ahorraremos ir escribiendo la contrasenña cada vez que ejecutemos una operación