VLAN Mikrotik Basado en Puertos

VLANs Mikrotik - Basada en Puertos. Tenemos dos routers Mikrotik (RouterOS).

Internet

El router Mikrotik esta conectado desde el puerto ehter1 (WAN_ether1) a uno de los puertos ethernet del router ISP, usando DHCP Client.

[admin@R1] /ip dhcp-client> print
Flags: X - disabled, I - invalid, D - dynamic 
 #   INTERFACE    USE-PEER-DNS ADD-DEFAULT-ROUTE STATUS      ADDRESS           
 0   ether1        yes          yes               bound       192.168.88.12/24  

Todos los puertos de un switch por defecto pertenecen a la la vlan 1. El switch necesita de un router para mover (forwarding) el tráfico entre las vlan. Eso permite la comunicacion entre diferentes VLAN.

Las VLAN ID solo aparecen en Switch administrables y funcionan en capa 2. La segmentación se produce en el Switch.

El Switch tiene una base de datos llamada tabla CAM donde realiza un seguimiento de cada computadora conectada:

- MAC Address
- Numero de Puerto
- VLAN ID - Solo en Switches Administrables

Las VLANs se utilizan se utilizan para segmentar una red, lo que permite mejorar la seguridad, el rendimiento y la gestion de la red. Los dispositivos de una VLAN pueden ser configurados y administrados de forma separada.

Los dispositivos CRS (tienen capacidad de capa 3) se pueden utilizar como enrutador y conmutador al mismo tiempo, útil para redes que se centran en el rendimiento de la red interna.

VLAN - Laboratorio de pruebas

Ambos routers estan en blanco - System - Reset Configuration - No Default Configuration - Reset Configuration.

Tenemos un router 1 (R1) donde se crean las VLAN, vlan10 con vlan-id=10 y vlan20 con vlan-id=20 en la interfaz Ether3, cada una con su direccionamineto IP y un DHCP Server. Esas VLAN se envían Tagged (Trunk en Cisco) a través de Ether3 y se reciben Tagged en el router 2 (R2) en el puerto Ether1. Luego se entregan como Untagged (Access Port) en los puertos Ether3 y Ether4.

Configuración vía comandos del Router 1.

Nota: La dirección IP del dns-server correspnde al servidor DNS de mi red interna. Puede utilizar DNS públicos si no tiene un servidor DNS local, por ejemplo, 1.1.1.1 o los del propio router Mikrotik, por defecto 192.168.88.1.

/interface
add interface=ether2 name=vlan10 vlan-id=10
add interface=ether2 name=vlan20 vlan-id=20
/ip pool
add name=dhcp_pool0 ranges=10.10.10.200-10.10.10.254
add name=dhcp_pool1 ranges=172.24.1.200-172.24.1.254
/ip dhcp-server
add address-pool=dhcp_pool0 disable=no interface=vlan10 name=dhcp1
add address-pool=dhcp_pool1 disable=no interface=vlan20 name=dhcp2
/ip address
add address=10.10.10.1/24 interface=vlan10 network=10.10.10.0
add address=172.24.1.1/24 interface=vlan20 network=172.24.1.0
/ip dhcp-server network
add address=10.10.10.0/24 dns-server=192.168.88.200 gateway=10.10.10.1
add address=172.24.1.0/24 dns-server=192.168.88.200 gateway=172.24.1.1

En el Router R2 se crean las VLAN en el puerto Ether1 que es donde recibimos las VLAN con el nombre y vlan-id correspondiente, vlan10 vlan-id=10 y vlan20 vlan-id=20. Teniendo en cuenta que para que las VLAN se comuniquen entre dispositivos el id debe ser el mismo. Tambien hay que crear un bridge por cada VLAN Bridge_VLAN10 y Bridge_VLAN20. En la pestaña Bridge - Bridge - Ports, agregar dos interfaces: la propia VLAN y el puerto físico donde quiero entregarla como acceso (Access Port). En el caso de la VLAN vlan10 los puertos son: la propia VLAN vlan10 y el puerto Ether3. En la VLAN vlan20 los puertos son: la propia VLAN vlan20 y el puerto Ether4. Evidentemente, si quiero entregar la misma VLAN en más puertos este último paso se repite para todos los puertos involucrados.

Configuracion vía comandos Router 2 (R2)

/interface vlan
add interface=ether1 name=vlan10 vlan-id=10
add interface=ether1 name=vlan20 vlan-id=20
/interface bridge
add name=Bridge_VLAN10
add name=Bridge_VLAN20
/interface Bridge port
add bridge=Bridge_VLAN10 interface=vlan10
add bridge=Bridge_VLAN10 interface=ether3
add bridge=Bridge_VLAN20 interface=vlan20
add bridge=Bridge_VLAN20 interface=ether4

IP Route R1

[admin@R1] /ip route> print
Flags: X - disabled, A - active, D - dynamic, 
C - connect, S - static, r - rip, b - bgp, o - ospf, m - mme, 
B - blackhole, U - unreachable, P - prohibit 
 #      DST-ADDRESS        PREF-SRC        GATEWAY         DISTANCE
 0 ADS  0.0.0.0/0                          192.168.88.1           1
 2 ADC  10.10.10.0/24      10.10.10.1      vlan10                 0
 3 ADC  172.24.1.0/24      172.24.1.1      vlan20                 0
 4 ADC  192.168.88.0/24    192.168.88.12   ether1                 0
 

Conecto un PC a Ether3 del router R2 y recibe una IP del DHCP-Server configurado en R1

[admin@R1] /ip dhcp-server lease print
Flags: X - disabled, R - radius, D - dynamic, B - blocked 
 #   ADDRESS              MAC-ADDRESS       H SE.. R STATUS  LAST-SEEN            
 0 D 10.10.10.251         E4:B9:7A:6B:96:CD s dh..   bound   4m6s  
 

(Opcional) -¿Cómo Permitir tráfico de VLANs?

/ip firewall filter
add chain=forward src-address=10.10.10.0/24 dst-address=172.24.1.0/24 \
connection-state=new,established action=accept comment="Permitir VLAN10 \
a VLAN20"

/ip firewall filter
add chain=forward src-address=172.24.1.0/24 dst-address=10.10.10.0/24 \
connection-state=new,established action=accept comment="Permitir VLAN20 \
a VLAN10"

Ubicación de las reglas:

Antes de cualquier regla que bloquee tráfico (ej. action=drop).
Usa el menú Drag & Drop en Winbox para ordenarlas.

Explicacion:

Las opciones connection-state=new,established permiten:
new: Conexiones iniciadas desde el origen.
established: Respuestas al tráfico iniciado.

Permitir acceso administrativo sólo desde la red 10.10.10.1/24

add chain=input src-address=10.10.10.1/24 protocol=tcp dst-port=22,8291,8728,8729 \
action=accept comment="Acceso administrativo (Winbox/SSH/API)"

Reglas de cortafuegos R1

admin@R1VLAN] > /ip firewall filter print
Flags: X - disabled, I - invalid, D - dynamic 
 0    ;;; Permitir conexiones establecidas
      chain=input action=accept connection-state=established,related log=no log-prefix="" 

 1    ;;; Permitir ICMP
      chain=input action=accept protocol=icmp log=no log-prefix="" 

 2    ;;; Permitir conexiones establecidas
      chain=forward action=accept connection-state=established,related log=no log-prefix="" 

 3    ;;; Bloquear conexiones inva/ip lidas
      chain=forward action=drop connection-state=invalid log=no log-prefix="" 

 4    ;;; Permitir trafico forward in wlan1 y out vlan10
      chain=forward action=accept in-interface=wlan1 out-interface=vlan10 log=no log-prefix="" 

 5    ;;; Permitir forward in vlan10 y out wlan1
      chain=forward action=accept in-interface=vlan10 out-interface=wlan1 log=no log-prefix="" 

 6    ;;; Permitir trafico forward in wlan1 y out vlan20
      chain=forward action=accept in-interface=wlan1 out-interface=vlan20 log=no log-prefix="" 

 7    ;;; Perimtir trafico forward in vlan20 out wlan1
      chain=forward action=accept in-interface=vlan20 out-interface=wlan1 log=no log-prefix="" 

 8    ;;; Bloquear trafico no permitido
      chain=forward action=drop log=no log-prefix="" 

FreeBSD es genial!.

Firewall Mikrotik Protege LAN y Permite Acceso a Internet

Configuración de firewall para MikroTik (RouterOS)

Protege la red LAN (10.10.10.0/24) y permite acceso a Internet. Las reglas incluyen protección anti-spoofing, bloqueo de tráfico no autorizado, y permiten tráfico legítimo.

El router Mikrotik esta conectado al puerto ehter1 (WAN_ether1) y uno de los puertos ethernet del router ISP usando DHCP Client

Configuración básica de interfaces

/interface bridge
add name=LAN_bridge
/interface bridge port
add bridge=LAN_bridge interface=ether2
add bridge=LAN_bridge interface=ether3
add bridge=LAN_bridge interface=ether4
add bridge=LAN_bridge interface=ether5
add bridge=LAN_bridge interface=wlan1
add bridge=LAN_bridge interface=wlan2
/ip address
add address=10.10.10.1/24 interface=LAN_bridge

DHCP Client en WAN (WAN_ether1)

/ip dhcp-client
add interface=WAN_ether1

NAT para acceso a Internet

/ip firewall nat
add chain=srcnat out-interface=WAN_ether1 action=masquerade

POLÍTICAS POR DEFECTO (FILTER)

/ip firewall filter

CONEXIONES ESTABLECIDAS

add chain=input action=accept connection-state=established,related \
comment="Permitir conexiones Establecidas/Realacionadas (Input)"
add chain=forward action=accept connection-state=established,related \
comment="Permitir conexiones Establecidas/Relacionadas (Forward)"
add chain=output action=accept connection-state=established,related \
comment="Permitir conexiones Establecidas/Relacionadas (Output)"

ANTI-SPOOFING Y SEGURIDAD BÁSICA Bloqueo de IPs falsas en WAN

add chain=input action=drop in-interface=WAN_ether1 src-address=10.10.10.0/24 \
comment="Bloquear LAN IP Spoofing (Input)"
add chain=forward action=drop in-interface=WAN_ether1 src-address=10.10.10.0/24 \
comment="Bloquear LAN IP Spoofing (Forward)"

Protección contra escaneos y ataques comunes

add chain=input action=drop in-interface=WAN_ether1 protocol=tcp psd=21,3s,3,1 \
comment="Bloquear TCP SYN Scans"
add chain=input action=drop in-interface=WAN_ether1 protocol=udp

REGLAS INPUT (TRÁFICO AL ROUTER) Permitir administración solo desde LAN

add chain=input action=accept in-interface=LAN_bridge protocol=tcp dst-port=22,8291,443 \
comment="Acceso Administracion (LAN)"

Permitir ICMP (ping)

add chain=input action=accept protocol=icmp comment="Allow ICMP"

Permitir DHCP desde ISP

add chain=input action=accept in-interface=WAN_ether1 protocol=udp src-port=67-68 dst-port=67-68 \
comment="DHCP Cliente"

Bloquear todo lo demás en WAN

add chain=input action=drop in-interface=WAN_ether1 \
comment="Bloquear Todo WAN Input"

REGLAS FORWARD (TRÁFICO A TRAVÉS DEL ROUTER)

Permitir LAN -> Internet

add chain=forward action=accept in-interface=LAN_bridge out-interface=WAN_ether1 \
connection-state=new comment="LAN a Internet"

Bloquear Internet -> LAN (excepto respuestas)

add chain=forward action=drop in-interface=WAN_ether1 out-interface=LAN_bridge \
connection-state=new comment="Bloquear Internet a LAN"

Permitir tráfico entre interfaces LAN (opcional)

add chain=forward action=accept in-interface=LAN_bridge out-interface=LAN_bridge \
comment="Inter-LAN Tráfico"

REGLAS OUTPUT (TRÁFICO DESDE EL ROUTER)

add chain=output action=accept comment="Permitir Router Output" disabled=no

REGLAS ADICIONALES DE SEGURIDAD Bloqueo de redes reservadas/rfc1918 desde WAN

add chain=input action=drop in-interface=WAN_ether1 src-address-list=private_ranges \
comment="Bloquear IPs Privada (Input)"
add chain=forward action=drop in-interface=WAN_ether1 src-address-list=private_ranges \
comment="Bloquear IPs Privada (Forward)"

Lista de redes reservadas

/ip firewall address-list
add address=172.16.0.0/12 list=private_ranges
add address=10.0.0.0/8 list=private_ranges
add address=192.168.0.0/16 list=private_ranges
add address=169.254.0.0/16 list=private_ranges

LOGGING (OPCIONAL)

add chain=input action=log log-prefix="[BLOQUEO DE CORTAFUEGOS] " \
comment="Log Bloqueado Input"
add chain=forward action=log log-prefix="[BLOQUEO DE CORTAFUEGOS] " 
comment="Log Bloqueado Forward"

Configurar servicios:

/ip service
set ssh address=10.10.10.0/24,192.168.88.0/24
set winbox address=10.10.10.0/24,192.168.88.0/24
set ftp disable=yes
set telnet disable=yes
set api disable=yes
set api-ssl disable=yes
set www disable=yes
set www-ssl disable=yes

Protección bridge:

/interfaces bridge settings
set use-ip-firewall=yes

Protección extra:

/ip firewall filter
add chain=forward protocol=tcp tcp-flags=syn,!ack action=drop comment="Bloquear SYN-flood"
add chain=forward protocol=udp limit=10/1m action=drop comment="Limite UDP floods"

Explicación:

1. Conexiones Establecidas: - Acepta tráfico de respuestas en todas las cadenas (input, forward, output).

2. Protección Anti-Spoofing: - Bloquea tráfico WAN con IPs de la LAN (10.10.10.0/24). - Bloquea redes reservadas (RFC 1918) desde WAN.

3. Reglas INPUT: - Solo permite administración (SSH, Winbox, WebFig) desde la LAN. - Permite ICMP (ping) y DHCP del ISP. - Bloquea todo el tráfico entrante no autorizado en WAN.

4. Reglas FORWARD: - Permite nuevas conexiones desde LAN hacia Internet. - Bloquea nuevas conexiones desde Internet hacia LAN. - Permite comunicación entre dispositivos LAN (opcional).

5. Reglas OUTPUT: - Permite todo el tráfico generado por el router (se puede ajustar si es necesario).

6. Protección Adicional: - Bloqueo de escaneos TCP/UDP desde Internet. - Logging de tráfico bloqueado para diagnóstico.

Notas: - Políticas por Defecto: - Input: drop (implícito por reglas). - Forward: drop (regla final bloquea tráfico no autorizado). - Output: accept.

- NAT: La regla masquerade en srcnat permite a la LAN acceder a Internet usando la IP WAN (asignada por DHCP).

- Personalización: - Para permitir acceso desde Internet (ej: servidor web), agregar reglas `forward` específicas. - Ajustar puertos de administración en reglas `input` según necesidades.

Esta configuración equilibra seguridad y funcionalidad, protegiendo la LAN de amenazas externas mientras permite acceso a Internet.

FreeBSD es genial!.

Evitar el Doble NAT - Traduccion de Nombres de Red

Evitar el doble NAT

Cuando el router del módem y el router inalámbrico están conectados en serie, es posible que encuentre algunos problemas con su servicio de Internet debido a la doble NAT (traducción de direcciones de red).

Una posible solución

Crear una ruta estatica en el router de la operadora que cualquier paquete que llegue para la red 192.168.88.0/24 lo envie a la dirección del router 192.168.1.43 que él lo gestionará y el router neutro (Mikrotik) enviará los paquete al dispositivo conrrespondiente, suponiendo que tiene su propia LAN 192.168.88.0/24 y la IP de la puerta de enlace de los dispositivos que se conectan el segundo router seria la 192.168.88.1. Los dispositivos que se conectan a él le asignaria la direccion IP el DHCP del router neutro. La puerta de enlace del router neutro es la 192.168.1.1

Advanced Setup -> Routing -> Static Routes

IP Version DstIP/Prefix/Length Gateway 		Interface  metric
4 	   192.168.88.0/24     192.168.1.43     LAN/Br0    1

FreeBSD es genial!.

NFSv4 FreeBSD 14.2

NFSv4 - NFS Version 4 Protocol FreeBSD 14.2

Como administrador de un servidor NFS, puede configurarlo para que sólo admita NFSv4, lo que minimiza el número de puertos abiertos y servicios en ejecución en el sistema.

Opcionalmente, también puede deshabilitar la escucha de las llamadas de protocolo RPCBIND, MOUNT, y NSM, que no son necesarias en el caso de sólo NFSv4.

En este momento, es posible habilitar NFSv3 y/o NFSv4 sobre TCP, pero no NFSv3 sobre UDP, de todas maneras, NFSv3 sobre UDP está en desuso. Esto significa que la opción "-u" No se puede especificar para nfs_server_flags en el archivo /etc/rc.conf.

sharenfs=off|on Controla si el sistema de archivos se comparte a través de NFS y que acciones van a ser utilzadas. Un sistema de archivos con una sharenfs=off es administrado con el comando exportfs y entradas en el archivo /etc/exports. Por ejemplo

zfs get sharenfs zroot/usr/backup/dellhome
NAME                       PROPERTY  VALUE     SOURCE
zroot/usr/backup/dellhome  sharenfs  off       local

El archivo exports especifica puntos de montaje remotos para el protocolo NFS. Cada linea especifica el punto de montaje e indicadores de exportacion dentro de un sistema de archivos del servidor local o la raiz del arbol NFSv4 para uno o mas hosts.

En el servidor NFSv4 archivo /etc/rc.conf

sysrc nfs_server_enable="YES"
sysrc nfsv4_server_enable="YES"
sysrc nfs_server_flags="-u -t -n 24"
sysrc hostid_enable="YES"
sysrc hostid_file="/etc/hostid"
sysrc rpcbind_enable="YES"
sysrc rpcbind_flags="-h 192.168.88.160"
sysrc mountd_enable="YES"
sysrc mountd_flags="-r -p 892"
sysrc statd_flags="-p 32766"
sysrc lockd_flags="-p 32767"

Iniciar servicio hostid

service hostid start

Parametros des sysctl (/etc/sysctl.conf)

sysctl vfs.nfs.enable_uidtostring="1"      # Hacer que NFS siempre envíe nombres de propietario numéricos
sysctl vfs.nfsd.enable_stringtouid="1"     # Habilitar nfsd para aceptar nombres de propietario numéricos
sysctl vfs.nfsd.server_max_nfsvers="4"     # Fuerza NFSv4 max
sysctl vfs.nfsd.server_min_nfsvers="4"     # Fuerza NFSv4 min
sysctl vfs.nfsd.issue_delegations="1"      # Habilita delegaciones (mejora rendimiento)
sysctl vfs.nfsd.enable_locallocks="1"      # Bloqueos locales (compatible con ZFS)
sysctl kern.ipc.somaxconn="1024"           # Max conexciones pendientes (por defecto 128)
sysctl net.inet.tcp.delayed_ack="0"        # Mejora rendimiento TCP

Hacer que los cambios sean permanentes

echo vfs.nfs.enable_uidtostring="1" >> /etc/sysctl.conf
echo vfs.nfsd.enable_stringtouid="1" >> /etc/sysctl.conf
echo vfs.nfsd.server_max_nfsvers="4" >> /etc/sysctl.conf
echo vfs.nfsd.server_min_nfsvers="4" >> /etc/sysctl.conf
echo vfs.nfsd.issue_delegations="1" >> /etc/sysctl.conf
echo vfs.nfsd.enable_locallocks="1" >> /etc/sysctl.conf
echo kern.ipc.somaxconn="1024" >> /etc/sysctl.conf
echo net.inet.tcp.delayed_ack="0" >> /etc/sysctl.conf

Usamos el archivo /etc/hosts como resolución de nombres en la red local

...
192.168.88.160		tormenta
192.168.88.51		solaris
...

Configurar PF para permitir el tráfico NFS

...
lan_net ="{ 192.168.88.0/24 10.10.10.0/24 }"
nfs_puertos="{ 111, 892, 2049 }"
statd_lockd_puertos="{ 32766, 32767 }"

pass in proto { tcp } from $lan_net to any port ssh
pass in proto { tcp udp } from $lan_net to any port $statd_lockd_puertos
pass in proto { tcp udp } from $lan_net to any port $samba_puertos
pass in quick proto { tcp udp } from $lan_net to any port $nfs_puertos
...

Reiniciar servicios

tormenta: # service nfsd restart
Stopping nfsd.
Waiting for PIDS: 1391 1394.
Starting nfsd.

tormenta: # service rpcbind restart
Stopping rpcbind.
Waiting for PIDS: 1285.
Starting rpcbind.

tormenta: # service mountd restart
Stopping mountd.
Waiting for PIDS: 1382.
Starting mountd.

Crear los conjunto de datos en el servidor

zfs create -o mountpoint=/nfsv4/dellhome -p zroot/nfsv4/dellhome
zfs create -o mountpoint=/nfsv4/poolrecovery -p zroot/nfsv4/poolrecovery
zfs create -o mountpoint=/nfsv4/docs -p zroot/nfsv4/docs
zfs create -o mountpoint=/nfsv4/desarrollo -p zroot/nfsv4/desarrollo
zfs create -o mountpoint=/nfsv4/confsolaris -p zroot/nfsv4/confsolaris
zfs create -o mountpoint=/nfsv4/conftormenta -p zroot/nfsv4/conftormenta

Archivo de ejemplo /etc/exports, directorios compartidos en redes LAN

tormenta: # cat /etc/exports
V4: /nfsv4 # Define /nfsv4 como raiz global
/nfsv4/dellhome -alldirs -network 192.168.88.0/24,10.10.10.0/24
/nfsv4/poolrecovery -alldirs -maproot=root -network 192.168.88.0/24
/nfsv4/docs -alldirs -maproot=root -network 192.168.88.0/24,10.10.10.0/24
/nfsv4/desarrollo -alldirs -maproot=root -network 192.168.88.0/24
/nfsv4/confsolaris -alldirs -maproot=root -network 192.168.88.0/24
/nfsv4/conftormenta -alldirs -maproot=root -network 192.168.88.0/24

Puertos a la escucha (en el servidor)

root@tormenta:~ # netstat -an | grep -i listen     
tcp6       0      0 *.2049                 *.*                    LISTEN     
tcp4       0      0 *.2049                 *.*                    LISTEN     
tcp4       0      0 *.892                  *.*                    LISTEN     
tcp6       0      0 *.892                  *.*                    LISTEN          
tcp4       0      0 *.111                  *.*                    LISTEN     
tcp6       0      0 *.111                  *.*                    LISTEN 

carlos@tormenta:~ % sockstat -l4 | grep -E 'nfsd|rpcbind|mountd'
root     nfsd        1391 5   tcp4   *:2049                *:*
root     mountd      1382 8   udp4   *:892                 *:*
root     mountd      1382 9   tcp4   *:892                 *:*
root     rpcbind     1285 9   udp4   *:111                 *:*
root     rpcbind     1285 10  udp4   *:898                 *:*
root     rpcbind     1285 11  tcp4   *:111                 *:*

Programar mantenimiento

# crontab -e
@daily /sbin/service mountd reload
@daily /sbin/service nfsd restart

Logs de errorres:

 tail /var/log/messages | grep nfs

Capturar tráfico NFS:

 tcpdump -i re0 port 2049 -w nfs-captura.pcap

Leer paquetes capturados del archivo nfs-captura.pcap

root@tormenta:~ # tcpdump -r nfs-captura.pcap

...
21:14:42.658371 IP solaris.960 > tormenta.nfsd: Flags [P.], seq 976297794:976297922, \
ack 2292617495, win 4352, options [nop,nop,TS val 2858673986 ecr 2537679775], length 128: \
NFS request xid 755722369 124 getattr fh 0,5/2
21:14:42.658440 IP tormenta.nfsd > solaris.960: Flags [.], ack 128, win 29128, options \
[nop,nop,TS val 2537739395 ecr 2858673986], length 0
21:14:42.658497 IP tormenta.nfsd > solaris.960: Flags [P.], seq 1:93, ack 128, win 29128, \
options [nop,nop,TS val 2537739395 ecr 2858673986], length 92: NFS reply xid 755722369 \
reply ok 88 getattr LNK 12231267145 ids 1/53 sz 0
21:14:42.658797 IP solaris.960 > tormenta.nfsd: Flags [.], ack 93, win 4352, options \
[nop,nop,TS val 2858673987 ecr 2537739395], length 0
...

Configurar cliente FreeBSD

cat /etc/hosts...
192.168.88.160		tormenta
192.168.88.51		solaris
...

Para que el servicion nfs client se inicie con el sistema

solaris:~ # sysrc nfs_client_enable=YES
solaris:~ # sysrc nfsv4_client_enable="YES"
solaris:~ # sysrc hostid_enable="YES"
solaris:~ # sysrc hostid_file="/etc/hostid"
solaris:~ # sysrc rpc_statd_enable="YES"
solaris:~ # sysrc rpc_lockd_enable="YES"

Iniciar servicio hostid

service hostid start

Iniciar el servicio nfsclient

solaris:~ # service nfsclient start
NFS access cache time=60

solaris:~ nc -v tormenta 2049
  Connection to tormenta 2049 port [tcp/nfsd] succeeded!

solaris:~ nc -v tormenta 111
Connection to tormenta 111 port [tcp/sunrpc] succeeded!

Montar manualmente un directorio compartido (en el cliente)

solaris:~ # mkdir /mids4
# mount -t nfs -o nfsv4 tormenta:/docs /mids4

Archivo /etc/fstab para un montaje permanente y automático

# Device	Mountpoint	FStype	Options		Dump	Pass#
/dev/gpt/efiboot0	/boot/efi	msdosfs	rw		2	2
/dev/nvd0p3	 none	  	swap	sw			0	0
# 
fdesc		/dev/fd			fdescfs	rw		0	0
#
proc			/proc		procfs	rw		0	0
# nfsv4 shared
tormenta:/poolrecovery     /nisc4    nfs     rw,nfsv4,noatime,bg    0  0
tormenta:/development      /nixs4    nfs     rw,nfsv4,noatime,bg    0  0
tormenta:/docs             /nids4    nfs     rw,nfsv4,noatime,bg    0  0
tormenta:/dellhome 	   /nihs4    nfs     ro,nfsv4,noatime,bg    0  0

Archivo /etc/auto_master

cat /etc/auto_master
#
# Automounter master map, see auto_master(5) for details.
#
/net		-hosts		-nobrowse,nosuid,intr

Configurar el montaje automatico para montar dinámicamente cuando alguien acceda al recurso compartido NFS.

echo 'autofs_enable="YES"' >> /etc/rc.conf

service automountd start

Vamos a comprobar que podemos escribir en el directorio

 cd /nids4
 vim script-while-files.sh 
#!/bin/sh
i=0
while [ $i -le 10 ]
do
	 echo 'creando archivos con contenido'
	i=$(($i+1))
	echo Hola > "file$i.txt"
done
:wq

 chmod +x script-while-files.sh
 ./script-while-files.sh
 ls
 file3.txt             file8.txt
file1.txt             file4.txt             file9.txt
file10.txt            file5.txt             script-while-files.sh
file11.txt            file6.txt
file2.txt             file7.txt

solaris:~ % mount

...
map -hosts on /net (autofs)
tormenta:/poolrecovery on /nisc4 (nfs, nfsv4acls)
tormenta:/dellhome on /nihs4 (nfs, read-only, nfsv4acls)
tormenta:/docs on /nids4 (nfs, nfsv4acls)
tormenta:/development on /nics4 (nfs, nfsv4acls)
...

Verificar PF y reglas en tiempo real

 pfctl -f /etc/pf.conf
 pfctl -s rules

FreeBSD es genial!.

Servidor VPN con ZeroTier FreeBSD Raspberry Pi

Para crear una VPN se necesita:

1.- Un Servidor VPN
2.- Configuración de los clientes VPN
3.- Servicio DDNS (para conocer la IP pública de nuestro servidor)
4.- Abrir los puertos en el Router y poder acceder desde el exterior al servidor VPN
5.- No estar detrás de un CG-NAT.

Como acceder a nuestra red de una manera segura, cifrada (cifrado de 256 bits), saltándonos el CG-NAT en caso de que nuestro proveedor de Internet lo utilice, sin abrir puertos y sin servicio DDNS?.

La respuesta es el servicio ZeroTier, (SD-WAN), gratuito para uso personal (25 dispositivos). Con ZeroTier podremos unir equipos, unir redes, tanto si están dentro de la red como fuera de la misma. Podremos acceder desde cualquier ordenador, teléfono, cualquer dispositivo que tengamos dentro de nuestra red pero desde fuera de la red.

Para conseguirlo utilizaremos una raspberrypi (Raspberry Pi 3B) y la convertimos en un servidor VPN. Instalamos el sistema operativo raspbian en un disco externo SSD Intel de 40GB. No es necesario configurar una dirección estática porque no se usa el reenvío de puertos en el Router. Y sí, necesitamos el acceso vía SSH por lo que lo habilitaremos.

La red virtual asignada por ZeroTier es la 192.168.192.0/24, también puede crear su propia red o elegir otra red de las ofrecidas por ZeroTier desde su panel dec control. Debe ser una subred diferente a la subred que tenemos. Por ejemplo, yo tengo la subred 192.168.88.0/24 que no coincide con la red virtual de ZeroTier, la 192.168.192.0/24.

La dirección IP de mi servidor VPN es 192.168.8.12 accedemos a través de un portátil FreeBSD a la Raspberry Pi a través de la red.

% ssh carlos@192.168.88.12

ifconfig servidor VPN

ifconfig solaris FreeBSD

FreeBSD Instalar Wordpress

Instalar Wordpress en la jail

1.- Creación de la Jail www con Bastille

2.- Instalar Apache MySQL PHP

3.- Instalar Wordpress. Activar rdr en Firewall PF

Creación de la base de datos para Wordpress

bastille console www

root@www: #

Instalación de Wordpress

Inicicar sesión en mysql como usuario root

root@www: # mysql -h 127.0.0.1 -u root -p
Password:

root@127.0.0.1 [(none)]> ALTER USER 'root'@'localhost' IDENTIFIED BY 'su_password';
Query OK, 0 rows affected (0.01 sec)

root@127.0.0.1 [(none)]> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

Crear un usuario, una base de datos para Wordpress y una contraseña, otorgar los derechos en la base de datos al usuario creado.

CREATE DATABASE db_wp;
Query OK, 1 row affected (0.00 sec)

USE db_wp;

CREATE USER 'db_wp'@'localhost' IDENTIFIED BY '57rMvRbev&5o$eE*sV';

GRANT ALL PRIVILEGES ON db_wp.* TO 'db_wp'@'localhost' IDENTIFIED BY \
'57rMvRbev&5o$eE*sV';
Query OK, 0 rows affected (0.00 sec)

Recargar las cachés internas de MySQL con el comando FLUSH

FLUSH PRIVILEGES;

Salir de mysql

root@localhost [(none)]> exit
Bye
root@www: #

Descargar y descomprimir la última version de Wordpress

root@www: # fetch https://wordpress.org/latest.tar.gz

Descomprimir el archivo

tar -zxvf latest.tar.gz

Entrar en el directorio de wordpress y copiar wp-config-sample.php a wp-config.php

cd wordpress
cp wp-config-sample.php wp-config.php

Edite el archivo wp-config.php e introduzca DB_NAME, DB_USER y DB_PASSWORD

 vim wp-config.php

define( 'DB_NAME', 'db_wp' );^M
^M
/** Database username */^M
define( 'DB_USER', 'db_wp' );^M
^M
/** Database password */^M
define( 'DB_PASSWORD', '57rMvRbev&5o$eE*sV' );^M

Reiniciar mysql-server

root@www: # service mysql-server restart

Mover el contenido del directorio de Wordpress a la ubicación reservada a los sitios de FreeBSD, /usr/local/www/apache24/data

 cp -r ~/wordpress/* /usr/local/www/apache24/data

Cambiar el propiepario y grupo de los archivos a www

 chown -R www:www /usr/local/www/apache24/data

Llegados a este punto, vamos a crear el archivo rdr.conf para hacer las reglas de redirección de puertos persistentes. Las reglas que se encuentran en este archivo (una por línea) se cargarán para la jail cada vez que se inicie, y se borran automáticamente cuando se detenga la jail.

cd /usr/local/bastille/jails/www
fstab     jail.conf     root

vim .conf
 tcp 80 80
 tcp 443 443
ls /usr/local/bastille/jails/www/
fstab     jails.conf    rdr.conf    root

FIGURA rdr.conf

Cambios en el archivo pf.conf

rdr pass inet proto tcp from any to any port {80, 443} -> $www_ip.
Redirigir, dejar pasar todo el tráfico TCP de cualquier origen, que tenga como destino los puertos 80 y 443, a la IP de la jail, utilizando la macro $www_ip que define la dirección IP 10.10.10.2

Firewall PF

carlos@solaris:~ $ cat /etc/pf.conf
#
ext_if="em0"
www_ip="10.10.10.2"

set skip on lo
set block-policy return
scrub in on $ext_if all fragment reassemble

table <jails> persist
nat on $ext_if from <jails> to any -> ($ext_if:0)
rdr-anchor "rdr/*"
rdr pass inet proto tcp from any to any port {80, 443} -> $www_ip

block in all
pass out quick keep state
antispoof for $ext_if inet

pass in inet proto tcp from any to any port ssh flags S/SA keep state

Reiniciar la jail

 bastille restart www

Apuntar Firefox a la dirección IP o nombre de dominio para proceder a la instalación de Wordpress

http://10.10.10.2:80/wp/wp-admin/install.php

Sólo falta instalar Wordpress usando el asistente de instalación y un nombre de usuario y una contraseña para la administración del sitio web.

FreeBSD es genial!.

Gestión de Jails con Bastille FreeBSD

Jails con Bastille FreeBSD

https://docs.freebsd.org/en/books/handbook/jails/
https://bastille.readthedocs.io/en/latest/

1.- Creación de la Jail www con Bastille

2.- Instalar Apache MySQL PHP

3.- Instalar Wordpress. Activar rdr en Firewall PF

Información sobre el sistema

% uname -mrs
FreeBSD 13.1-RELEASE-p6 amd64

La virtualización es algo así como un entorno cliente-servidor. El hardware y su instancia central del sistema operativo es el host, mientras que los clientes son instancias virtualizadas del sistema operativo. Una jail contiene una zona de usuario completa del sistema operativo que se ejecuta sobre un sistema FreeBSD existente. La jail no tiene su propio kernel, en cambio, se ejecuta en una porción restringida del kernel del host.

Un sistema enjaulado sólo puede acceder a una parte limitada del sistema de archivos y no puede ver procesos fuera de la jaula. A cada jaula se le asigna una dirección IP dedicada, y la jaula sólo puede ver el tráfico a esa IP en particular. Cada jaula necesita un directorio raíz dedicado

La cuenta root en una jaula controla completamente esa jaula pero no tiene acceso a nada más allá de la jaula, está confinado. El usuario puede instalar el software que desee sin interferir con el sistema anfitrión ni con otras jaulas.

Bastille es un gestor de jails escrito en Bourne Shell.

Soporta ZFS
VNET
Automatización de jails por medio de templates
Control de recursos (rctl)
Firewall dinámico - redirección dinámica de puertos, etc.
La red interna de la jail hará nat a través de PF

El comando ping está deshabilitado dentro de los contenedores, porque el acceso sin procesar al socket es un agujero de seguridad. En su lugar, se puede instalar y probar con wget.

 pkg install bastille

Habilitar las opciones para utilizar ZFS en bastille

 sysrc -f /usr/local/etc/bastille/bastille.conf bastille_zfs_enable=YES
 sysrc -f /usr/local/etc/bastille/bastille.conf bastille_zfs_zpool=zroot

Activar bastille

 sysrc bastille_enable=YES

Iniciar bastille

service bastille start

Descargar los ficheros base de la última versión de FreeBSD que vamos a utilizar y aplicar parches de seguridad.

# bastille bootstrap 13.1-RELEASE update

Bucle invertido bastille0

loopback (bastille0)

Crear una interfaz loopback clonada (bastille0) y asignar direcciones privadas (rfc1918) a todos las jails en esa interfaz. Se puede usar cualquier dirección dentro de ese rango porque hemos creado nuestra propia red privada.

Desde el sistema host el cortafuegos (PF), permite y deniega tráfico. Con esta configuración los contenedores se mantienen fuera de la red, hasta que se permita el acceso.

El NAT del cortafuegos del sistema saca el tráfico de los contenedores y puede redirigir selectivamente el tráfico a los contenedores en función de los puertos de conexión (es decir, 80, 443, etc.)

Crear la interfaz loopback

 sysrc cloned_interfaces+=lo1
 sysrc ifconfig_lo1_name="bastille0"

Aplicar la configuración

 service netif cloneup

PF es una herramienta de manipulacion TCP/IP

Permitir conexiones SSH

$ cat /etc/pf.conf
#
ext_if="em0"

set skip on lo
set block-policy return
scrub in on $ext_if all fragment reassemble

table <jails> persist
nat on $ext_if from <jails> to any -> ($ext_if:0)
rdr-anchor "rdr/*"

block in all
pass out quick keep state
antispoof for $ext_if inet

pass in inet proto tcp from any to any port ssh flags S/SA keep state

Habilitar PF

# sysrc pf_enable=YES

Iniciar PF

 service pf start

Consultar las reglas de PF

pfctl -sr

scrub in on em0 all fragment reassemble
block return in all
pass out quick all flags S/SA keep state
block drop in on ! em0 inet from 192.168.88.0/24 to any
block drop in inet from 192.168.88.51 to any
pass in inet proto tcp from any to any port = ssh flags S/SA keep state

Crear la jail www y asignarle la dirección IP 10.10.10.2

bastille create www 13.1-RELEASE 10.10.10.2
Valid: (10.10.10.2).
...
Creating a thinjail...

Listar las jails

solaris: # bastille list
 JID             IP Address      Hostname       Path
 www             10.10.10.2      www            /usr/local/bastille/jails/www/root

Entrar en la jail www para ver su dirección IP

 bastille console www
[www]:
root@www:~ #
root@www:~ # uname -mrs
FreeBSD 13.1-RELEASE-p6 amd64
 

Ejecutar ifconfig

Crear un usuario no privilegiado para Habilitar conexiones SSH desde el host

Entrar en la jail

 bastille console www
 root@www:~ # adduser
 ...

SSH Secure Shell

Salir de la jail

root@www:~ # exit
logout

Habilitar e iniciar el servicio SSH en la jail

 bastille sysrc www sshd_enable=YES
 bastille service www sshd start

Establecer el Port 23 y la ListenAddress 10.10.10.2 en el archivo de configuración /etc/ssh/sshd_config

Port 23
ListenAddress 10.10.10.2

Reiniciar el servicio

 service sshd restart

Se puede saber si el socket está a la escucha ejecutando

bastille cmd www sockstat -4

[www]:
USER     COMMAND    PID   FD PROTO  LOCAL ADDRESS         FOREIGN ADDRESS
root     sshd       55610 3  tcp4   10.10.10.2:23         *:*
[www]: 0

También podemos entrar en la jail y lanzar el comando nc localhost 23

 bastille console www

root@www:~ # nc localhost 23
SSH-2.0-OpenSSH_8.8 FreeBSD-20211221

SSH le permite generar una huella digital de clave, que es una representación mucho más corta de una clave. No puedes encriptar el tráfico o negociar con la huella dactilar. Para generar una huella de clave pública, introduzca el comando ssh-keygen -lf keyfile.pub.

root@www:~ # ssh-keygen -lf /etc/ssh/ssh_host_rsa_key.pub

Salir de la jail

root@www:~ # exit
logout

En el host agregar al archivo .ssh/config los datos de conexión

carlos@solaris:~ cat .ssh/config
Host www
    HostName 10.10.10.2
    User carlos
    Port 23
    AddressFamily inet
    BindInterface em0
    IdentityFile ~/.ssh/id_rsa

    CASignatureAlgorithms ssh-ed25519,ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,sk-ssh-ed25519@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,rsa-sha2-512,rsa-sha2-256

    Ciphers  chacha20-poly1305@openssh.com,aes128-ctr,aes192-ctr,aes256-ctr,aes128-gcm@openssh.com,aes256-gcm@openssh.com

    CheckHostIP yes

Entrar a la jail www a través de SSH

carlos@solaris:~/.ssh % ssh www
The authenticity of host '[10.10.10.2]:23 ([10.10.10.2]:23)' can't be established.
ED25519 key fingerprint is SHA256:KEnjnUTz7FPyq2c+ZcEzKvu+s5diszqxff+DmFJ+0sI.
No matching host key fingerprint found in DNS.
This host key is known by the following other names/addresses:
    ~/.ssh/known_hosts:45: www
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[10.10.10.2]:23' (ED25519) to the list of known hosts.

Dentro de la jail www

carlos@www:~ $

Cambiar al usuario root

carlos@www:~ $ su
root@www: #

Instalar wget para comprobar que tenemos acceso a Internet

 pkg install wget
The package management tool is not yet installed on your system.
Do you want to fetch and install it now? [y/N]: y

En este punto tenemos la jail instalada y con conexion a Internet.

Detener la jail

bastille stop www

Iniciar la jail

bastille start www

[www]:
www: created

Archivos de configuracion de Bastille jails

ls /usr/local/bastille/jails/www
fstab     jail.conf root

Archivo jails.conf de bastille

# cat /usr/local/bastille/jails.conf
www {
  devfs_ruleset = 4;
  enforce_statfs = 2;
  exec.clean;
  exec.consolelog = /var/log/bastille/www_console.log;
  exec.start = '/bin/sh /etc/rc';
  exec.stop = '/bin/sh /etc/rc.shutdown';
  host.hostname = www;
  mount.devfs;
  mount.fstab = /usr/local/bastille/jails/www/fstab;
  path = /usr/local/bastille/jails/www/root;
  securelevel = 2;

  interface = bastille0;
  ip4.addr = 10.10.10.2;
  ip6 = disable;
}

FreeBSD es genial!.

Jails VNET iocage FreeBSD 13.1

Usar VNET con una jail usando iocage

klara Systems. Virtualise your network on FreeBSD with VNET
iocage 1.2 documentation

Las pilas de red virtual VNET de FreeBSD, una potente tecnología de aislamiento de pila de red que otorga superpoderes a las cárceles de FreeBSD.

iocage es un administrador de cárceles (jails) que combina algunas de las características y tecnologiías de FreeBSD, iocage requiere ZFS para funcionar. Utiliza archivos de configuración almacenados con cada cárcel individual. Cuando iocage inicia, lee sus propios archivos de configuración y activa jail para crear e iniciar todas las cárceles que ha marcado para el inicio automático.

Las cárceles configuradas en jail.conf no entran en conflicto con las adminstradas por iocage. Ambos sistemas funcionan de forma independiente.

La gestión de hosts Unix se hace a través de sshd. Cada cárcel tendrá su propia IP.

Las reglas de TCP/IP dicen que solo un proceso puede escuchar en una combinación de dirección IP y puerto a la vez. SSH por defecto se conecta al puerto 22 en todas las direcciones IP en un huésped. Los host usan el puerto 22, las cárceles usan el puerto 23.

Entrar al host (tormenta) vía SSH

 ssh carlos@tormenta

Restringir la dirección IP de escucha del host

ListenAddress 192.168.88.160

Reiniciar el servicio sshd

 service sshd restart

El demonio ntpd escucha en todas las direcciones IP posible. Las cárceles toman su tiempo del anfitrión.

Instalar iocage

 pkg install py39-iocage

Dependencias de iocage

 pkg search -d py39-iocage
py39-iocage-1.2_10
Comment        : FreeBSD jail manager written in Python3
Depends on     :
        py39-requests-2.28.1_1
        py39-texttable-1.6.7
        ca_root_nss-3.87
        py39-netifaces-0.11.0
        py39-tqdm-4.64.1
        python39-3.9.16
        py39-dnspython-2.2.1_1,1
        rcs57-5.7
        py39-typing-extensions-4.4.0
        py39-setuptools-63.1.0
        py39-libzfs-1.1.2022081600
        py39-jsonschema-4.16.0
        py39-gitpython-3.1.30
        py39-coloredlogs-15.0.1
        py39-click-8.1.3
        git-2.39.1

Montar el sistema de ficheros de descriptores de ficheros

 mount -t fdescfs null/dev/fd

Agregamos esta entrada a /etc/fstab para hacerlo permanente

 fdesc  /dev/fd   fdescfs rw    0       0

uname -a

FreeBSD tormenta 13.1-RELEASE-p3 FreeBSD 13.1-RELEASE-p3 GENERIC amd64

Comprobar el nombre del zpool

 zpool list
NAME    SIZE  ALLOC   FREE  CKPOINT  EXPANDSZ   FRAG    CAP  DEDUP    HEALTH  ALTROOT
zroot   448G  79.3G   369G        -         -     1%    17%  1.00x    ONLINE  -

Activar el zpool

 iocage activate zroot
ZFS pool 'zroot' successfully activated.

Descargar la versión de FreeBSD que será la base de nuestros jails

 iocage fetch

Press [Enter] to fetch the default selection: (13.1)
ENTER

Creación de una Jail con VNET activada

FreeBSD 13.1 habilita la compatibilidad con VNET de forma predeterminada, lo que otorga a cada cárcel su propia pila de red y facilita el encarcelamiento de aplicaciones individuales utilizando iocage.

Dirección IP estática del servidor tormenta y router por defecto /etc/rc.conf

...
ifconfig_re0="inet 192.168.88.160 netmask 255.255.255.0"
defaultrouter="192.168.88.1"
...

Archivo revolv.conf

cat /etc/resolv.conf
# Generated by resolvconf
nameserver 192.168.88.200

interface Ethernet

 ifconfig
re0: flags=8943<UP,BROADCAST,RUNNING,PROMISC,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=82099<RXCSUM,VLAN_MTU,VLAN_HWTAGGING,VLAN_HWCSUM,WOL_MAGIC,LINKSTATE>
        ether 88:ae:dd:0c:a5:c6
        inet 192.168.88.160 netmask 0xffffff00 broadcast 192.168.88.255

media: Ethernet autoselect (1000baseT <full-duplex,master>)
        status: active
...

Habilitar iocage

 sysrc iocage_enable=YES

Crear un bridge

# VNET iocage
cloned_interfaces="bridge0"
ifconfig_bridge0="addm re0 up"

Agregue estos parámetros ajustables a /etc/sysctl.conf

net.inet.ip.forwarding=1       # Enable IP forwarding between interfaces
net.link.bridge.pfil_onlyip=0  # Only pass IP packets when pfil is enabled
net.link.bridge.pfil_bridge=0  # Packet filter on the bridge interface
net.link.bridge.pfil_member=0  # Packet filter on the member interface

Crear una jail llamada vikingo con VNET activada, una direccón IP estática (192.168.88.254) defaultrouter 192.168.88.1

bpf="yes"         # Alternar el inicio de la jaula con los dispositivos Berkely 
                    Packet Filter habilitados
-n "vikingo"      # Nombre de la jail
-r                # jail basada en 13.1-RELEASE FreeBSD
allow_raw_sockets # Permitir ping
vnet="on"         # Usar VNET
boot="on"         # Inicar jail al arranque
defaultrouter="192.168.88.1" # Router por defecto
ip4_addr="192.168.88.250/24 # Dirección IP fija de la jail

Creación de la jail

 iocage create -n "vikingo" -r 13.1-RELEASE vnet="on" bpf="yes" \
allow_raw_sockets="1" boot="on" defaultrouter="192.168.88.1" \
ip4_addr="192.168.88.254/24"
vikingo successfully created!

Al inicio de una cárcel, el sistema copia automáticamente /etc/resolv.conf del host a la cárcel. Si la información no es correcta, puede utilizar la propiedad resolver de iocage para actualizarla.

 iocage set resolver="nameserver 192.168.88.200" vikingo
resolver: /etc/resolv.conf -> nameserver 192.168.88.200

Comprobar ping desde otra máquina en la red

solaris:~ % ping -c 2 192.168.88.254
PING 192.168.88.254 (192.168.88.254): 56 data bytes
64 bytes from 192.168.88.254: icmp_seq=0 ttl=64 time=0.546 ms
64 bytes from 192.168.88.254: icmp_seq=1 ttl=64 time=0.314 ms

--- 192.168.88.254 ping statistics ---
2 packets transmitted, 2 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 0.314/0.430/0.546/0.116 ms

Visualizar las cárceles

# iocage list
+-----+----------+-------+--------------+-------------------+
| JID |   NAME   | STATE |   RELEASE    |        IP4        |
+=====+==========+=======+==============+===================+
+-----+----------+-------+--------------+-------------------+
| 1   | vikingo  | up    | 13.1-RELEASE | 192.168.88.254/24 |
+-----+----------+-------+--------------+-------------------+

Para acceder a la consola de una jail

 iocage console jailnombre

La jail no ve la red del host

exec - Iniciar comando dentro de la jail

iocage exec vikingo ifconfig

 lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> metric 0 mtu 16384
        options=680003<RXCSUM,TXCSUM,LINKSTATE,RXCSUM_IPV6,TXCSUM_IPV6>
        inet6 ::1 prefixlen 128
        inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1
        inet 127.0.0.1 netmask 0xff000000
        groups: lo
        nd6 options=21<PERFORMNUD,AUTO_LINKLOCAL>
epair0b: flags=8863<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=8<VLAN_MTU>
        ether 88:ae:dd:ff:a6:c2
        hwaddr 02:3f:a6:be:0e:0b
        inet 192.168.88.254 netmask 0xffffff00 broadcast 192.168.88.255
        inet6 fe80::8aae:ddff:feff:a6c2%epair0b prefixlen 64 scopeid 0x2
        groups: epair
        media: Ethernet 10Gbase-T (10Gbase-T <full-duplex>)
        status: active
        nd6 options=21<PERFORMNUD,AUTO_LINKLOCAL>

interfaces en el host

 ifconfig
re0: flags=8943<UP,BROADCAST,RUNNING,PROMISC,SIMPLEX,MULTICAST> metric 0 mtu 1500
        options=8209b<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,VLAN_HWCSUM,WOL_MAGIC,LINKSTATE>
        ether 88:ae:dd:0c:a5:c6
        inet 192.168.88.160 netmask 0xffffff00 broadcast 192.168.88.255
        inet 192.168.88.210 netmask 0xffffff00 broadcast 192.168.88.255
        media: Ethernet autoselect (1000baseT <full-duplex,master>)
        status: active
        nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> metric 0 mtu 16384
        options=680003<RXCSUM,TXCSUM,LINKSTATE,RXCSUM_IPV6,TXCSUM_IPV6>
        inet6 ::1 prefixlen 128
        inet6 fe80::1%lo0 prefixlen 64 scopeid 0x2
        inet 127.0.0.1 netmask 0xff000000
        groups: lo
        nd6 options=21<PERFORMNUD,AUTO_LINKLOCAL>
vnet0.5: flags=8862<BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        description: associated with jail: vikingo as nic: epair0b
        options=8<VLAN_MTU>
        ether 88:ae:dd:ff:a6:c1
        hwaddr 02:35:3d:4b:cb:0a
        groups: epair
        media: Ethernet 10Gbase-T (10Gbase-T <full-duplex>)
        status: active
        nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
bridge0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
        ether 58:9c:fc:10:ff:ba
        id 00:00:00:00:00:00 priority 32768 hellotime 2 fwddelay 15
        maxage 20 holdcnt 6 proto rstp maxaddr 2000 timeout 1200
        root id 00:00:00:00:00:00 priority 32768 ifcost 0 port 0
        member: re0 flags=143<LEARNING,DISCOVER,AUTOEDGE,AUTOPTP>
                ifmaxaddr 0 port 1 priority 128 path cost 20000
        groups: bridge
        nd6 options=9<PERFORMNUD,IFDISABLED>

Python3 está instalado en el host y como nuestro jail no aísla el sistema de archivos, todo el software instalado también está disponible para el jail podemos usar el servidor http integrado en python3 para mostrar un servicio de red simple que se ejecuta dentro de la cárcel.

 iocage exec vikingo sh -c "cd /root; python3 -m http.server"
Serving HTTP on :: port 8000 (http://[::]:8000/) ...
::ffff:192.168.88.51 - - [30/Jan/2023 14:56:29] "GET / HTTP/1.1" 200 -

Un navegador web en una máquina host puede apuntar a 192.168.88.254:8000 y podemos navegar por la estructura del árbol fuente de FreeBSD que vive en /root de la jail

http://192.168.88.254:8000

Entramos en la jail vikingo

 iocage console vikingo

Vamos a crear el directorio /usr/local/www

mkdir /usr/local/www

Y dentro del directorio www el archivo index.html

<html><body><p><em>vikingo: Lunes 30 enero 16:47 PDT 2023</p></em></body></html>

Salimos de la jaula tecleando exit y usamos el servidor http integrado en python para mostrar index.html en el navegador

tormenta: # iocage exec vikingo sh -c "cd /usr/local/www; python3 -m http.server"
Serving HTTP on :: port 8000 (http://[::]:8000/) ...

Desde otra máquina de la red

http://192.168.8.26.254:8000

# iocage exec vikingo sh -c "cd /usr/local/www; python3 -m http.server"
Serving HTTP on :: port 8000 (http://[::]:8000/) ...
::ffff:192.168.88.51 - - [30/Ene/2023 19:10:08] "GET / HTTP/1.1" 304 -

El archivo config.json creado automáticamente por iocage de la jail

 # cat /iocage/jails/vikingo/config.json
{
    "allow_raw_sockets": 1,
    "boot": 1,
    "bpf": 1,
    "cloned_release": "13.1-RELEASE",
    "defaultrouter": "192.168.88.1",
    "host_hostname": "vikingo",
    "host_hostuuid": "vikingo",
    "ip4_addr": "192.168.88.254/24",
    "jail_zfs_dataset": "iocage/jails/vikingo/data",
    "last_started": "2023-01-28 21:04:54",
    "release": "13.1-RELEASE-p5",
    "resolver": "nameserver 192.168.88.200",
    "vnet": 1,
    "vnet0_mac": "88aeddffa6c1 88aeddffa6c2"
}

Entrar en la jaula

 iocage console vikingo

Last login: Wed Feb  8 18:49:10 on pts/1
FreeBSD 13.1-RELEASE-p3 GENERIC

Welcome to FreeBSD!

Release Notes, Errata: https://www.FreeBSD.org/releases/
Security Advisories:   https://www.FreeBSD.org/security/
FreeBSD Handbook:      https://www.FreeBSD.org/handbook/
FreeBSD FAQ:           https://www.FreeBSD.org/faq/
Questions List: https://lists.FreeBSD.org/mailman/listinfo/freebsd-questions/
FreeBSD Forums:        https://forums.FreeBSD.org/

Documents installed with the system are in the /usr/local/share/doc/freebsd/
directory, or can be installed later with:  pkg install en-freebsd-doc
For other languages, replace "en" with a language code like de or fr.

Show the version of FreeBSD installed:  freebsd-version ; uname -a
Please include that output and any error messages when posting questions.
Introduction to manual pages:  man man
FreeBSD directory layout:      man hier

To change this login announcement, see motd(5).
root@vikingo:~ # 

Instalar wget

# pkg install wget
The package management tool is not yet installed on your system.
Do you want to fetch and install it now? [y/N]: y
Bootstrapping pkg from pkg+http://pkg.FreeBSD.org/FreeBSD:13:amd64/quarterly, please wait...
Verifying signature with trusted certificate pkg.freebsd.org.2013102301... done
[vikingo] Installing pkg-1.19.0...
[vikingo] Extracting pkg-1.19.0: 100%
Updating FreeBSD repository catalogue...
[vikingo] Fetching meta.conf: 100%    163 B   0.2kB/s    00:01
[vikingo] Fetching packagesite.pkg: 100%    6 MiB   1.1MB/s    00:06
Processing entries: 100%
FreeBSD repository update completed. 32411 packages processed.
All repositories are up to date.
Updating database digests format: 100%
The following 5 package(s) will be affected (of 0 checked):

New packages to be INSTALLED:
        gettext-runtime: 0.21.1
        indexinfo: 0.3.1
        libidn2: 2.3.4
        libunistring: 1.1
        wget: 1.21.3_1

Number of packages to be installed: 5

The process will require 8 MiB more space.
2 MiB to be downloaded.

Proceed with this action? [y/N]:

Detener una jail

# iocage stop vikingo
* Stopping vikingo
  + Executing prestop OK
  + Stopping services OK
  + Removing devfs_ruleset: 1001 OK
  + Removing jail process OK
  + Executing poststop OK

Inicar jail vikingo

 iocage start vikingo
* Starting vikingo
  + Started OK
  + Using devfs_ruleset: 1000 (iocage generated default)
  + Configuring VNET OK
  + Using IP options: vnet
  + Starting services OK
  + Executing poststart OK

Obtener el hostid de una jail

 iocage get hostid vikingo
1867b930-d81e-6f28-017a-88aedd0ca5c6

Destruir una jail

-f Destruye la jaula sin advertencias o intervención del usuario

 iocage destroy nombrejail -f

Reiniciar jail

 iocage restart vikingo
* Stopping vikingo
  + Executing prestop OK
  + Stopping services OK
  + Tearing down VNET OK
  + Removing devfs_ruleset: 1000 OK
  + Removing jail process OK
  + Executing poststop OK
* Starting vikingo
  + Started OK
  + Using devfs_ruleset: 1000 (iocage generated default)
  + Configuring VNET OK
  + Using IP options: vnet
  + Starting services OK
  + Executing poststart OK

Gestión de snapshots

Una de las funcionalidades más interesantes son los snapshots. Se crean ejecutando el siguiente comando

 iocage snapshot -n snap_vikingo00 vikingo
Snapshot: zroot/iocage/jails/vikingo@snap_vikingo00 created.

Ver los snapshots de una jail

 iocage snaplist vikingo
+---------------------+-----------------------+-------+------+
|        NAME         |        CREATED        | RSIZE | USED |
+=====================+=======================+=======+======+
| snap_vikingo00      | Tue Jan 31  7:41 2023 | 108K  | 0B   |
+---------------------+-----------------------+-------+------+
| snap_vikingo00/root | Tue Jan 31  7:41 2023 | 1.64G | 0B   |
+---------------------+-----------------------+-------+------+

El primer snapshot contiene el directorio de configuración de la jail (config.json fstab). El segundo snapshot de la raiz de la jail

Revertir la jail

Antes se detiene la jail

 iocage stop vikingo

Revertir el conjunto de datos a una instantánea

 iocage rollback -n snap_vikingo00 vikingo

Dump snapshot

Crear snapshot de la carcel con iocage

 iocage snapshot -n snap00_vikingo vikingo
Snapshot: zroot/iocage/jails/vikingo@snap00_vikingo created.

Listar snapshots

iocage snaplist vikingo

 iocage snaplist vikingo
+---------------------+-----------------------+-------+------+
|        NAME         |        CREATED        | RSIZE | USED |
+=====================+=======================+=======+======+
| snap00_vikingo      | Tue Jan 31  9:35 2023 | 116K  | 0B   |
+---------------------+-----------------------+-------+------+
| snap00_vikingo/root | Tue Jan 31  9:35 2023 | 1.47G | 0B   |
+---------------------+-----------------------+-------+------+

Visualizar desde ZFS

zfs list -t snapshot| grep vikingo
zroot/iocage/jails/vikingo@snap00_vikingo        0B      -      116K  -
zroot/iocage/jails/vikingo/root@snap00_vikingo   0B      -     1.47G  -
zroot/iocage/releases/13.1-RELEASE/root@vikingo  0B      -     1.46G  -

Tenemos dos snapshots, nos interesa el del sistema de ficheros raiz

Dump snapshot a un fichero

 zfs send zroot/iocage/jails/vikingo/root@snap00_vikingo > /root/vikingo.raw

Es recomendable hacer copias los ficheros de configuracion

 cp /iocage/jails/vikingo/config.json /root/vikingo
 cp /iocage/jails/vikingo/fstab /root/vikingo

Destruir el snapshot

 iocage snapremove -n snap00_vikingo vikingo
Snapshot: zroot/iocage/jails/vikingo@snap00_vikingo destroyed

Comprobar

 zfs list -t snapshot | grep vikingo
zroot/iocage/releases/13.1-RELEASE/root@vikingo   0B   -     1.46G  -

Restaurar el dataset ZFS

 zfs recv -dvu zroot/iocage/jails/vikingo < /root/vikingo/vikingo.raw
receiving full stream of zroot/iocage/jails/vikingo/root@snap01_vikingo_310123 \
into zroot/iocage/jails/vikingo/iocage/jails/vikingo/root@snap01_vikingo_310123
received 2.74G stream in 5 seconds (561M/sec)

FreeBSD es genial!.