hits counter

FreeBSD:



Instalar el sistema operativo

FreeBSD es una versión libre (como Linux) del sistema operativo UNIX realizada por la Universidad de California en Berkeley, que tomó como punto de partida la variante 4.4 BSD-Lite de UNIX. Pero tiene un par de diferencias con Linux: mientras que éste se creó tomando como modelo a UNIX, FreeBSD deriva directamente de él, y a diferencia de Linux, FreeBSD no es sólo el núcleo (o kérnel) del sistema operativo, sino que además incluye la estructura del sistema de ficheros, las bibliotecas de la API y algunas utilidades.

FreeBSD también posee versiones para procesadores de distintas arquitecturas: Intel, MIPS, PowerPC, UltraSPARC... y para ARM. Desde el servidor FTP de freebsd.org podemos descargar la versión para la Raspberry Pi. Elegiremos la última versión STABLE, ya que la versión CURRENT se encuentra en proceso de desarrollo.

Descargamos el fichero bz2 correspondiente a la RPi, lo guardamos en una carpeta y lo descomprimimos. Luego, en Windows, usaremos la aplicación Win32DiskImager para instalarlo en la tarjeta SD, siguiendo el mismo proceso que realizamos en el caso de Raspbian.

Terminada la copia en la tarjeta SD, el sistema operativo está listo para arrancar. Habrá que hacerlo forzosamente conectando un monitor y un teclado a la Raspberry, ya que FreeBSD sólo incluye por defecto al usuario root, el administrador del sistema. Y dado que el servidor SSH no permite, por motivos de seguridad (en su configuración por defecto), el login de root, el primer acceso al sistema no podremos realizarlo mediante SSH.

En nuestro caso hemos utilizado un adaptador HDMI-VGA para conectar el monitor al puerto HDMI de la RasPi. Para solucionar los problemas de imagen en el monitor (la pantalla aparecía en negro) hemos tenido que añadir al fichero config.txt, que se encuentra en la raíz de la partición FAT32, las siguientes líneas:

hdmi_force_hotplug=1
hdmi_drive=2
hdmi_group=1
hdmi_mode=4
disable_overscan=0
overscan_left=20
overscan_right=20
overscan_top=20
overscan_bottom=20


Configuración básica del sistema

Cuando el sistema arranque nos pedirá el nombre de usuario (root) y la contraseña. El administrador viene sin contraseña, así que basta con pulsar la tecla Intro. Más adelante le pondremos una contraseña a root.

Para poder acceder por SSH y evitarnos así el uso de un monitor y un teclado exclusivos para la Raspberry, lo primero que hemos de hacer es añadir un usuario al sistema. Lo haremos mediante el comando

adduser

Como es habitual, se nos pedirán una serie de datos, los más importantes de los cuales son el nombre de usuario y la contraseña. Pero en el caso de FreeBSD es también muy importante incluir a los usuarios del sistema en el grupo wheel. Por ello, cuando aparezca una línea como esta:

Login group is xxx. Invite xxx into other groups? []: wheel

tendremos que contestar con wheel, como se muestra en el ejemplo. Al final, se nos preguntará si los datos son correctos (escribimos yes) y luego si queremos añadir otro usuario (contestamos no).

Para evitar posibles problemas futuros con el arranque de FreeBSD, es necesario hacer una modificación en el fichero de arranque del sistema (/boot/loader.conf):

echo 'hw.bcm2835.sdhci.hs="0"' >> /boot/loader.conf

Hecho lo anterior, y conociendo la IP local de la Raspberry, ya podremos acceder por SSH con el nuevo usuario que hemos creado. Pero primero hay que apagar FreeBSD, para lo que escribiremos el comando habitual:

shutdown -h now

Unos segundos después ya podremos desconectar la RasPi, ya que si pulsamos una tecla (como se indica en la pantalla) reiniciaremos el sistema operativo en vez de apagarlo.

Durante el primer arranque de FreeBSD se ejecuta automáticamente la expansión del sistema de ficheros para que ocupe todo el espacio disponible en la tarjeta SD, por lo que este paso no hace falta hacerlo manualmente, como en Raspbian.

Usar una IP estática

Vamos a asignar una IP estática a nuestra Raspberry Pi. Para ello nos convertimos en root con el comando

su

Escribimos la contraseña del administrador (es decir, pulsamos Intro) y procedemos a editar el fichero /etc/rc.conf:

vi /etc/rc.conf

Tenemos que usar el editor vi para ello, puesto que nano no está incluido en el sistema. Más adelante lo instalaremos, ya que es más fácil de usar, pero por ahora tendremos que conformarnos con vi. Para quien no haya usado nunca este editor, estos son algunas de las teclas que hemos de pulsar para realizar la modificación del fichero y guardarlo al final:

Insertar texto antes del cursor    --> i  
Insertar texto después del cursor  --> a  
Guardar los cambios y salir        --> :wq  
Salir sin guardar los cambios      --> :q!

Vamos a incluir varias líneas en el mencionado fichero de configuración, de manera que quede así:

ifconfig_ue0="inet 192.168.1.33 netmask 255.255.255.0"
defaultrouter="192.168.1.1"
keymap="spanish.iso.acc"
sshd_enable="YES"

En la primera línea indicamos la IP de la RasPi y la máscara de red. En la segunda, la del gateway o puerta de enlace (es decir, el router). Después ponemos el teclado en español, lo que nos vendrá muy bien en caso de volver a conectar un monitor y un teclado para utilizar el sistema.

Una vez guardado el fichero, para que los cambios surtan efecto, tenemos que ejecutar estos dos comandos (o bien reiniciar el sistema):

/etc/rc.d/netif restart
/etc/rc.d/routing restart

Configurar la fecha y la hora

Empezaremos por poner la zona horaria más adecuada a nuestra localización geográfica (por ejemplo, Europa/Madrid):

cp /usr/share/zoneinfo/Europe/Madrid /etc/localtime

Conectamos con el servidor correspondiente para actualizar la fecha y la hora:

ntpdate -u -b pool.ntp.org

Para que el sistema realice la actualización en cada arranque, editamos el fichero /etc/rc.conf y añadimos al final estas líneas:

ntpdate_enable="YES"
ntpdate_flags="-u -b"
ntpdate_hosts="pool.ntp.org"

Otros cambios

Vamos a aprovechar que estamos configurando el sistema para ponerle una contraseña al administrador:

passwd root

Si no aparecen ya puestas, añadiremos también las DNS que usemos habitualmente en el fichero /etc/resolv.conf:

nameserver 8.8.8.8
nameserver 8.8.4.4

Otra cosa que podemos hacer es configurar adecuadamente el servidor SSH para aumentar su seguridad, tal y como vimos en el apartado correspondiente a Raspbian. En el caso de FreeBSD lo haremos modificando este fichero:

vi /etc/ssh/sshd_config

Realizados los cambios oportunos, reiniciamos el servidor SSH:

service sshd restart


Introducción al uso de los ports

En FreeBSD se usa el término ports para hacer referencia a colecciones de ficheros fuente que se instalan en el sistema por medio del comando make. Forman la base del método de gestión de paquetes de este sistema operativo. La primera vez que se usa FreeBSD hay que llevar a cabo el proceso de descargar todos los ports con el comando

portsnap fetch

Si es la primera vez que usamos el comando anterior, a continuación tendremos que extraerlos para que se coloque cada uno en su directorio correspondiente:

portsnap extract

A partir de entonces, de vez en cuando debemos actualizar la lista de ports. Para ello usaremos estos dos comandos:

portsnap fetch
portsnap update

Una vez descargados y extraídos los ports, ya podemos instalar aplicaciones. Vamos a instalar, por ejemplo, el editor nano. Primero buscamos el port correspondiente:

whereis nano

El sistema nos contestará mostrándonos la ruta del programa:

nano: /usr/ports/editors/nano

Así que vamos a esa ruta y lo instalamos:

cd /usr/ports/editors/nano
make install clean

Durante el proceso se nos puede preguntar, como en este caso, si queremos instalar también otros ficheros relacionados (por ejemplo, documentación relativa al port):

Si se interrumpe la instalación de un port, y al reinstalar da error (Error Code 1), nos situamos en su directorio y escribimos make clean distclean install clean para volver a instalarlo. Si continúa el error, podemos limpiar la instalación fallida con make clean distclean.

ATENCIÓN: La extracción de los ports y la posterior instalación de cada uno de ellos normalmente es un proceso bastante largo que puede durar mucho tiempo, debido a la gran cantidad de dependencias que es necesario compilar y a la escasa potencia del procesador de la Raspberry, así como a la baja velocidad de lectura/escritura de las tarjetas SD (comparado con los procesadores de los PCs y los discos duros o SSD que se usan en ellos). Por eso, para evitar una espera que puede resultar exasperante, podemos abrir otra sesión de SSH y seguir trabajando con el sistema mientras se llevan a cabo las tareas de compilación, instalación y configuración de los diferentes ports.

Naturalmente, también podemos desinstalar un port previamente instalado. En el caso, por ejemplo, del editor nano, haríamos esto:

cd /usr/ports/editors/nano
make deinstall

Portmaster y portupgrade

Un par de herramientas útiles para trabajar con los ports y sus actualizaciones son postmaster y portupgrade. Vamos a instalar la primera:

cd /usr/ports/ports-mgmt/portmaster
make install clean

y ya podemos, entre otras cosas, actualizar la lista de todos los ports disponibles:

portmaster -a

Si nos encontramos con errores durante el proceso de actualización, podríamos utilizar el modificador -f para actualizar o recompilar todos los ports:

portmaster -af

Es posible ver una lista de los ports instalados en el sistema y comprobar si hay actualizaciones para ellos usando el modificador -L:

portmaster -L

Ahora instalaremos la segunda herramienta:

cd /usr/ports/ports-mgmt/portupgrade
make install clean

Con ella podremos, por ejemplo, actualizar todo los ports que tengamos instalados en el sistema:

portupgrade -a

Si queremos que nos pida confirmación antes de actualizar cada paquete individual, añadiremos otro parámetro:

portupgrade -ai

También es posible actualizar una aplicación concreta:

portupgrade -R nano

Por otro lado, es importante evitar que se acumulen restos de las instalaciones en el sistema, ya que, con el paso del tiempo, pueden acabar ocupando bastante espacio. Al usar el parámetro clean después de make install, se borra automáticamente el directorio temporal work que se crea dinámicamente durante la instalación de los diferentes ports. De no ser así, y con portupgrade previamente instalado, podemos eliminar esos directorios con el comando

portsclean -C

También se pueden eliminar los distfiles que hayan quedado en el directorio /usr/ports/distfiles y que no tengan relación con ningún port:

portsclean -D

O borrar cualquier distfile que no tenga relación con ningún port de los que tengamos actualmente instalados en el sistema:

portsclean -DD


Usar un pendrive con formato ext4

Vamos a montar un pendrive previamente formateado en ext4, el formato propio de Linux que usamos en Raspbian, de forma que podamos intercambiarlo entre ambos sistemas para pasar archivos de Raspbian al nuevo sistema operativo que estamos usando ahora. Lo primero que haremos, una vez arrancado FreeBSD con el pendrive conectado, será escribir estos tres comandos para comprobar que el sistema detecta el dispositivo y le asigna un nombre (normalmente será da0s1, según podremos comprobar con el último comando):

dmesg | grep da0
gpart show da0
ls /dev/da0*

Luego realizamos una serie de operaciones de montaje en varios ficheros (debajo de la línea de rayas indicamos lo que hay que escribir en cada uno):

nano /etc/devfs.rules
------------------------------------------------------------------
[localrules=5]
add path 'da*' mode 0660 group operator

nano /etc/rc.conf
------------------------------------------------------------------
devfs_system_ruleset="localrules"

nano /etc/sysctl.conf
------------------------------------------------------------------
vfs.usermount=1

Creamos el directorio de montaje del dispositivo y le asignamos al usuario como su dueño:

cd /media
mkdir pen
chown pi:pi pen

Instalamos Fuse:

cd /usr/ports/sysutils/fusefs-ext4fuse
make install clean

Cargamos el driver:

kldload fuse.ko

Y hacemos que se cargue en cada arranque:

nano /boot/loader.conf
------------------------------------------------------------------
fuse_enable="YES"
fuse_load="YES"

Montamos el pendrive en su directorio y comprobamos que podemos acceder a su contenido:

ext4fuse /dev/da0s1 /media/pen
cd /media/pen
ls -l

A partir de ahora, para montar de nuevo el pendrive en los siguientes arranques, sólo habrá que usar la orden ext4fuse /dev/da0s1 /media/pen.



Formatear y montar un pendrive

Acabamos de aprender a montar un pendrive con ext4, el formato propia de Linux. Ahora vamos a usar otro pendrive, pero esta vez lo vamos a formatear en ufs, el formato característico de FreeBSD.

Lo primero que debemos hacer es desmontar el dispositivo:

umount -a

Ahora procedemos a formatearlo en ufs2 con el comando newfs:

newfs -L pendrive -O2 -U -m 6 /dev/da0

En la orden anterior, pendrive es la etiqueta del dispositivo y /dev/da0 es como lo nombra FreeBSD.

Una vez formateado, en /media creamos un subdirectorio para el dispositivo y lo montamos en él:

cd /media
mkdir pen
mount /dev/da0 /media/pen

Hecho lo anterior, ya podemos usar el pendrive para lo que queramos. Pero para no tener que hacer el proceso de montaje manualmente cada vez que reiniciemos el sistema, vamos a hacer que se monte automáticamente en cada arranque.

Editamos el fichero /etc/devfs.conf y añadimos el par de líneas que indicamos debajo:

nano /etc/devfs.conf
------------------------------------------------------------------
own     /dev/da0     root:operator
perm    /dev/da0    0666

Después añadimos esta otra línea al final del fichero /etc/fstab:

/dev/da0     /media/pen     ufs      rw,noatime     0  0

A partir de ahora, cada vez que arranquemos el sistema, el pendrive estará montado y listo para usar en el directorio /media/pen.



Servidor web Apache

Si por algo destaca FreeBSD es por su robustez. De ahí que muchas empresas e instituciones prefieran montar sus servidores mediante este sistema operativo. Vamos a instalar un servidor web en nuestra máquina. Para ello recurriremos al servidor más usado en Internet: Apache.

Instalamos el servidor:

cd /usr/ports/www/apache22
make install clean

Y hacemos que se inicie automáticamente cada vez que arranquemos el sistema, para lo que añadiremos una nueva línea al final del fichero /etc/rc.conf:

nano /etc/rc.conf
------------------------------------------------------------------
apache22_enable=”YES”

Editamos el fichero /etc/hosts y añadimos al final de cada una de las líneas el nombre de nuestra máquina, que debe corresponder con el hostname que aparece al principio del fichero /etc/rc.conf (y que normalmente será raspberry-pi):

::1                  localhost localhost.my.domain raspberry-pi
127.0.0.1       localhost localhost.my.domain raspberry-pi

Editamos también el archivo de configuración del servidor Apache. Buscamos una serie de líneas y las cambiamos, si fuera necesario, para que queden como se muestra a continuación:

nano /usr/local/etc/apache22/httpd.conf
------------------------------------------------------------------
ServerRoot "/usr/local"
Listen 80
ServerName raspberry-pi
DocumentRoot "/usr/local/www/apache22/data"

Por último, abrimos el fichero /boot/defaults/loader.conf, buscamos la línea accf_http_load=”NO” (que está en la sección "Other modules") y cambiamos el NO por YES, así:

accf_http_load=”YES”

Y ya podemos iniciar el servidor y comprobar que no hay errores:

/usr/local/etc/rc.d/apache22 start

Apache ya está listo para funcionar. Si en el PC abrimos el navegador y escribimos la IP local de la RasPi, podremos ver una página web de prueba que nos indica que el servidor está funcionando. Dicha página se encuentra en el directorio /usr/local/www/apache22/data, que es donde tenemos que copiar las páginas web que queramos mostrar.

Hay dos ficheros que nos dan información sobre el funcionamiento del servidor HTTP que acabamos de configurar:

  1. 1.) /var/log/httpd-access.log contiene la información relativa a los accesos al servidor.
  2. 2.) /var/log/httpd-error.log muestra información sobre errores o fallos en el acceso al mismo.



Servidor FTP

Instalaremos también un servidor de FTP para permitir que los usuarios puedan descargar ficheros de nuestra máquina. En concreto vamos a usar vsftpd, que es uno de los varios servidores FTP que podemos instalar en FreeBSD y que tiene fama de ser muy seguro.

Comenzamos, como es lógico, instalando el servidor:

cd /usr/ports/ftp/vsftpd
make install clean

Luego lo añadimos al arranque del sistema, incluyendo la siguiente línea al final del fichero /etc/rc.conf:

vsftpd_enable="YES"

Ahora creamos un usuario específico para el servidor, al que le asignaremos su correspondiente contraseña:

adduser ftpuser

Creamos el directorio /home/ftpuser:

cd /home
mkdir ftpuser

En el fichero /etc/shells incluimos una nueva línea que ponga lo siguiente:

/bin/false

Y en el fichero /etc/passwd comprobamos que el usuario ftpuser tenga puesta la shell /bin/false.

En el fichero de configuración /usr/local/etc/vsftpd.conf haremos modificaciones en las líneas incluidas en el mismo o añadiremos las que falten, de manera que las siguientes líneas, que son las más importantes, aparezcan así:

anonymous_enable=NO
local_enable=YES
listen=YES
background=YES
write_enable=NO
connect_from_port_20=YES
listen_port=21
pasv_min_port=23010
pasv_max_port=23020
max_clients=8
max_per_ip=2
max_login_fails=3
# Todos los usuarios van a este directorio cuando acceden al servidor
local_root=/home/ftpuser
# Niega el acceso a los usuarios listados en el fichero especificado
userlist_enable=YES
userlist_file=/etc/vsftpd.user_list
# Enjaulamos a los usuarios en el directorio /home/ftpuser
chroot_local_user=YES
chroot_list_enable=YES
# ... excepto los usuarios incluidos en el siguiente fichero
chroot_list_file=/etc/vsftpd.chroot_list

Ahora debemos crear el fichero /etc/vsftpd.user_list y meter en él a root. Después creamos el fichero /etc/vsftpd.chroot_list e incluimos en él a aquellos usuarios que no queremos que se enjaulen en el directorio /home/ftpuser, lo que significa que podrán moverse por todo el árbol de directorios del sistema.

Vamos a crear en el servidor, por ejemplo, un directorio o carpeta en la que guardar música:

cd /home/ftpuser
mkdir musica

Puede que, por motivos prácticos y de espacio, tengamos la música ya guardada en una carpeta dentro de un pendrive que previamente hemos montado en el sistema, como vimos más arriba. Para tener esa carpeta accesible en el directorio de descargas de nuestro server (es decir, en /home/ftpuser/musica) cada vez que arranquemos FreeBSD, haremos que se monte automáticamente modificando el fichero /etc/fstab e incluyendo en él la siguiente línea:

/media/pen/musica      /home/ftpuser/musica      nullfs  rw      0   0

Comprobamos, además, que en el fichero /etc/rc.conf aparezca la línea

hostname="raspberry-pi"

Por último, no debemos olvidar abrir en el firewall IPFW los puertos pasivos elegidos en el fichero de configuración (por ejemplo, del 23010 al 23020), así como los puertos TCP 20 y 21. Todos ellos, naturalmente, habremos de redirigirlos también en el router a la IP local de la Raspberry Pi si queremos que se pueda acceder al servidor desde Internet.

Para arrancar el servidor escribiremos este comando:

/usr/local/etc/rc.d/vsftpd start

Ahora comprobamos que el servidor funciona correctamente tecleando lo siguiente

ftp localhost

Escribimos el nombre de usuario (ftpuser) y la contraseña correspondiente al mismo y, si todo va bien, ya tenemos nuestro servidor FTP funcionando.

Pero tal vez obtengamos un mensaje de error como este:

500 OOPS: vsftpd: refusing to run with writable root inside chroot()

Este error ocurre porque vsftpd no permite que los usuarios puedan escribir en su carpeta raíz. Para solucionarlo, le quitarmos los permisos de escritura a esa carpeta:

cd /home
chmod 555 ftpuser

Para poder añadir o borrar contenido en esa carpeta, podemos cambiar los permisos provisionalmente mientras trabajamos con su contenido (chmod 755 ftpuser). Y además, cambiaremos el propietario de la misma de forma permanente:

chown pi:pi ftpuser


Transmission

Como hicimos en Raspbian, vamos a instalar también en FreeBSD el cliente de descargas P2P Transmission. El proceso de instalación es el habitual en FreeBSD:

cd /usr/ports/net-p2p/transmission-daemon
make install clean

En el directorio /media/pen que creamos antes para montar el pendrive, crearemos un subdirectorio llamado torrent para guardar las descargas, y le damos los permisos apropiados:

cd /media/pen
mkdir torrent
chown transmission:transmission torrent
chmod 775 torrent

Agregamos Transmission al sistema y le indicamos también el directorio de descargas que va a usar:

nano /etc/rc.conf
------------------------------------------------------------------
transmission_enable="YES"
transmission_watch_dir="/media/pen/torrent"
transmission_download_dir="/media/pen/torrent"

Tenemos que arrancar y detener el servicio para realizar las tareas de configuración:

/usr/local/etc/rc.d/transmission start
/usr/local/etc/rc.d/transmission stop

Ahora ya podemos editar el fichero de configuración de Transmission:

nano /usr/local/etc/transmission/home/settings.json
------------------------------------------------------------------
“incomplete-dir-enabled”: false,
"peer-port": 44027,
"rpc-authentication-required": true,
“rpc-bind-address”: “0.0.0.0″,
"rpc-enabled”: true,
“rpc-password”: “contraseña",
"rcp-port": 9091,
“rpc-username”: “nombre",
“rpc-whitelist-enabled”: false,

En las líneas anteriores indicaremos, en rpc-username y rpc-password, un nombre de usuario (por ejemplo, pi) y una contraseña para acceder al servicio. En cuanto a las líneas peer-port y rcp-port corresponden, respectivamente, al puerto de conexión para las descargas de torrents y al puerto de acceso a la interfaz web del programa.

Arrancamos la aplicación:

/usr/local/etc/rc.d/transmission start

y ya podemos acceder mediante el navegador del PC a la interfaz web de descargas de Transmission: escribiremos, como dirección, la IP local de nuestra Raspberry, seguida por dos puntos (:) y el puerto 9091 indicado antes. Así:

http://192.168.1.33:9091


Samba

Al igual que hicimos en el caso de Raspbian, vamos a instalar Samba también en FreeBSD para poder compartir archivos y carpetas con los demás ordenadores de nuestra red local.

Procedemos con la instalación:

cd /usr/ports/net/samba36
make install clean

Acabado el largo proceso, agregamos Samba al arranque del sistema:

nano /etc/rc.conf
------------------------------------------------------------------
samba_enable="YES"

Al fichero /usr/local/etc/smb.conf.sample le cambiamos el nombre por /usr/local/etc/smb.conf:

cp /usr/local/etc/smb.conf.sample /usr/local/etc/smb.conf

y lo abrimos con el editor para comenzar la configuración:

nano /usr/local/etc/smb.conf

Nos desplazamos a la línea que empieza por hosts allow, comprobamos que esté descomentada y la modificamos de acuerdo con las IPs o el rango de IPs de nuestra red local al que permitimos la conexión:

hosts allow = 192.168.1. 127.0.0.1

En este caso permitiremos la conexión a la propia RasPi (127.0.0.1 o localhost) y a los dispositivos de nuestra LAN cuya IP esté comprendida entre la 192.168.1.1 y la 192.168.1.254 (es decir, todo el rango de IPs de la red).

Si quisiéramos denegar el acceso a alguna IP concreta, podríamos añadir esta otra línea:

hosts deny = 192.168.1.20

Más abajo, nos aseguramos de que está presente (y descomentada) la línea

security = user

Al final del fichero añadimos las carpetas para compartir. Por ejemplo, la carpeta que creamos antes para guardar los torrents (/media/pen/torrent):

[torrent]
comment = carpeta para guardar torrents
path = /media/pen/torrent
browseable = yes
read only = no
writeable = yes
guest ok = no
public = no
create mask = 0777
directory mask = 0777

Esta carpeta que acabamos de configurar es privada, así que se nos pedirá el nombre de usuario y la contraseña asociada al mismo para poder acceder a ella desde la red.

Ahora añadimos el usuario pi al servidor:

smbpasswd -a pi

Nos pedirá una contraseña. Escribimos la misma del usuario pi de FreeBSD.

Ya sólo nos queda reiniciar el servidor:

/usr/local/etc/rc.d/samba restart

y comprobar que podemos acceder a la carpeta compartida mediante la IP local de la Raspberry. En Windows, usando el Explorador de archivos, sería así:

\\192.168.1.33


No-ip

Si no tenemos una IP fija o, aun teniéndola, si queremos disponer de un nombre de dominio para poder acceder desde Internet a nuestra Raspberry Pi, necesitaremos crear un dominio virtual. Podemos crear uno gratuitamente en No-ip, por ejemplo.

Una vez creado, instalamos el port correspondiente:

cd /usr/ports/dns/noip
make install clean

Nada más acabar la instalación, realizaremos la configuración del servicio:

make conf

Nos solicitará nuestros datos de la cuenta de No-ip (email y contraseña), comprobará el dominio (o dominios) virtual que tenemos y nos preguntará el tiempo de actualización del mismo, que por defecto es de 30 minutos.

Y lo único que falta es añadirlo al fichero /etc/rc.conf para que se inicie al arrancar el sistema:

nano /etc/rc.conf
------------------------------------------------------------------
noip_enable=”YES”


IPFW

El cortafuegos IPFW es uno de los varios que se incluyen en FreeBSD. Para un usuario con poca experiencia, seguramente es el menos difícil de configurar, motivo por el que nos hemos decantado por él. Lo primero que haremos será activar el cortafuegos en el arranque, y para ello incluiremos las siguientes líneas al final del fichero /etc/rc.conf:

nano /etc/rc.conf
------------------------------------------------------------------
firewall_enable="YES"
firewall_script="/etc/ipfw.rules"

La segunda línea es muy importante: en ella le decimos al sistema operativo en qué fichero vamos a incluir las reglas del firewall. Por ello, lo que haremos a continuación es detallar en dicho fichero las reglas que van a estar operativas en el cortafuegos, incluyendo los puertos que queremos que estén abiertos en nuestra máquina. Vamos a crear el fichero y a incluir en él todo lo necesario para que el cortafuegos haga correctamente su trabajo:

nano /etc/ipfw.rules
------------------------------------------------------------------
###################################################
ipfw -q -f flush                            # Borra todas las reglas
# Sustituciones simbólicas
oif="ue0"                                    # Interfaz Ethernet
odns="192.168.1.1"                    # Servidor de DNS (IP del router)
cmd="ipfw -q add"                     # Prefijo para añadir regla
ks="keep-state"                         # Creación dinámica de la regla
### Reglas ###
#Loopback device
$cmd 00100 allow ip from any to any via lo0
# Reglas básicas generales
$cmd 00150 check-state
$cmd 00160 allow icmp from any to any
$cmd 00170 allow tcp from any to any established
$cmd 00180 allow all from any to any out $ks
# Reglas relativas a los servicios que se usan y servidores instalados
# Permitir salida HTTP
$cmd 00300 allow tcp from any to any 80 out via $oif setup $ks
# Permitir DNS
$cmd 00310 allow tcp from any to $odns 53 out via $oif setup $ks
$cmd 00320 allow udp from any to $odns 53 out via $oif $ks
# Permitir acceso al servidor SSH
$cmd 00330 allow tcp from any to me 22 via $oif setup $ks
# Permitir Transmission
$cmd 00340 allow tcp from any to me 44027 via $oif setup $ks
$cmd 00350 allow tcp from any to me 9091 via $oif setup $ks
# Permitir Samba
$cmd 00360 allow tcp from any to me 139 via $oif setup $ks
$cmd 00370 allow tcp from any to me 445 via $oif setup $ks
$cmd 00380 allow udp from any to me 137 via $oif setup $ks
$cmd 00390 allow udp from any to me 138 via $oif setup $ks
# Permitir servidor HTTP Apache
$cmd 00395 allow tcp from any to me 80 via $oif setup $ks
# Permitir servidor FTP (vsftpd)
$cmd 00400 allow tcp from any to me 20 via $oif setup $ks
$cmd 00410 allow tcp from any to me 21 via $oif setup $ks
$cmd 00420 allow tcp from any to me 23010-23020 via $oif setup $ks
# Denegar cualquier otro
$cmd 00999 deny log all from any to any
###################################################

Como se puede observar, las reglas van numeradas (desde el 1 al 65534) para indicar el orden de su procesamiento. Las primeras líneas incluyen las sustituciones simbólicas que se usarán más adelante a la hora de definir las reglas, precedidas siempre del signo $; después se definen una serie de reglas básicas de carácter general; y por último abrimos los puertos correspondientes a los servicios que usamos habitualmente (HTTP, DNS) y los que se refieren a los servidores que tenemos instalados en el sistema: SSH, Transmission, Samba, Apache y FTP.

Una vez declaradas las reglas, ya sólo queda activar el cortafuegos:

service ipfw start

Dado que el firewall IPFW posee cierta complejidad, sobre todo si lo comparamos con la relativa sencillez de ufw, que es el que usamos con Raspbian, lo mejor es estudiar su funcionamiento en el manual on-line de FreeBSD, donde se detalla todo lo relativo a su uso y configuración.