Páginas

Mostrando entradas con la etiqueta dataset. Mostrar todas las entradas
Mostrando entradas con la etiqueta dataset. Mostrar todas las entradas

jueves, 19 de febrero de 2026

Migración de SSD a disco de mayor capacidad en FreeBSD 14.3 send receive vía USB

Estado actual del sistema

zpool status
zpool list 
zpool list -t all

Identificar discos

geom disk list
camcomtrol devlist

Anotar el disco actual (ada0) y el nuevo disco USB (da0)


Limpiar el disco nuevo completamente

gpart destroy -F da0
dd -if=/dev/zero of=/dev/da0 bs=1M count=100

Crear tabla de particiones GPT

gpart create -s gpt da0

Partición de arranque EFI (si el sistema usa UEFI)

gpart add -t efi -s 260M -l efiboot-new da0

Partición de arranque BIOS/GPT (para compatibilidad legacy)

gpart add -t freebsd-boot -s 512k -l gptboot-new da0

Partición swap

gpart add -t freebsd-swap -s 8G -a 1M -l swap0 da0

Particion ZFS (el resto del disco)

gpart add -t freebsd-zfs -a 1M -l zroot-new da0

Para sistemas UEFI


Montar partición EFI del disco nuevo

newfs_msdos -F 32 -c 1 /dev/da0p1
mount -t msdosfs /dev/da0p1 /mnt

Copiar EFI loader desde el actual disco

mkdir -p /mnt/EFI/BOOT
cp -r /boot/efi/EFI/BOOT /mnt/EFI/

umount /mnt

Crear pool temporal en el nuevo disco

Crear pool temporal con nombre diferente para evitar conflictos
zpool create -o altroot=/mnt \
             -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O acltype=posix \
             -m none \
             zroot-new /dev/da0p3

Verificar

zpool status zroot-new

Listar todos los datasets a migrar

zfs list -H -o name -t filesystem,volume

Tomar snapshot recursivo de todo el pool (Shell zsh)

sudo zfs snapshot -r zroot@migracion

Verificar snapshot creado

zfs list -t snapshot -o name | grep "$migracion" 
zroot@migracion
zroot/ROOT@migracion
zroot/ROOT/14.3-RELEASE-filebrowser-tailscale-serve-certs-https@migracion
zroot/ROOT/14.3-RELEASE_2026-02-14_193200@migracion
zroot/ROOT/default@2026-02-14-19:32:00-0
zroot/ROOT/default@2026-02-17-17:48:09-0
zroot/ROOT/default@migracion
zroot/home@migracion
zroot/home/carlos@migracion
zroot/tmp@migracion
zroot/usr@migracion
zroot/usr/ports@migracion
zroot/usr/src@migracion
zroot/var@migracion
zroot/var/audit@migracion
zroot/var/crash@migracion
zroot/var/log@migracion
zroot/var/mail@migracion
zroot/var/tmp@migracion

Enviar snapshot raíz primero

zfs send -Lec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Enviar recursivamente todos los datasets hijos

zfs send -RLec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Banderas (flags)

-R Recursivo (todos los datasets hijos)
-L Incluye large blocks
-e Embed data (bloques pequeños inline)
-c Comprime el stream
-F En receive: fuerza rollback si es necesario
-u No monta los datasets al recibirlos
-v Verbose

Comprobar la replicación


Comparar conjuntos de datos entre pools

zfs list -r zroot
zfs list -r zroot-new

Verificar propiedades

zfs get all zroot
zfs get all zroot-new

Cantidad de instantáneas

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zroot-new | wc -l

Configurar bootfs en el nuevo pool

zpool set bootfs=zroot-new/ROOT/default zroot-new

Verificar

zpool get bootfs zroot-new

Ajustar cachefile y otros parámetros del pool

zpool set cachefile=/boot/zfs/zpool.cache zroot-new

Ver propiedades del pool original para replicarlas

zpool get all zroot

Montar el dataset raíz del nuevo disco

zfs set mountpoint=/mnt zroot-new/ROOT/default
zfs mount zroot-new/ROOT/default

Verificar /boot/loader.conf

cat /mnt/boot/loader.conf

Debe contener algo como:

zfs_load="YES"
vfs.root.mountfrom="zfs:zroot/ROOT/default"

Si el nombre del pool cambió, actualizar:

sed -i '' 's/zroot-new/zroot/g' /mnt/boot/loader.conf

También verificar /etc/fstab (en ZFS puro suele estar sin referencias a ada0)

cat /mnt/etc/fstab

Cambiar el disco y primer arranque


Apagar el sistema

shutdown -p now

Desconectar el disco viejo Conectar el nuevo disco en el slot interno (ya no como USB) Comprobar en BIOS/UEFI que el nuevo disco sea el primero en el orden de arranque Arrancar

Verificación después del arranque


Comprobar salud del pool

zpool status
zpool list

Verificar que todos los datasets montaron

zfs list -t filesystem

Verificar espacio disponible (debe reflejar el disco nuevo mayor)

df -h

Verificar que el sistema arrancó desde el disco correcto

geom disk list
camcontrol devlist

Limpiar snapshots de migración

zfs destroy -r zroot@migracion

Problemas y posibles soluciones después del primer arranque


Renombrar zpool zroot-new a zroot

zpool import -f zroot-new zroot

Error

zpool export zroot-new Cannot unmount /

Es el error clásico: el dataset raíz (/) está montado desde zroot-new, así que ZFS no puede desmontarlo en caliente

Solución Desde loader prompt o LiveCD


Desde el LiveCD

zpool import -f zroot-new zroot
zpool set bootfs=zroot/ROOT/default zroot
zpool export zroot

zpool import -f zroot-new zroot
   zpool set bootfs=zroot/ROOT/default zroot
   zpool export zroot hecho.

Reiniciar

shutdown -r now

FreeBSD al arrancar y no encontrar zroot buscará pools disponibles. Si el disco nuevo ya está interno, lo encontrará como zroot-new y podrás importarlo con el nombre correcto.

Después de reiniciar sin el LiveCD el sistema arranca desde el nuevo disco duro.

Estos dos errores son normales y esperables en este proceso.

1. swapon: /dev/da0p3: No such file or directory, 
2. Import of zpool cache /etc/zfs/zpool.cache failed

El archivo /etc/fstab del sistema nuevo todavía referencia el dispositivo del disco USB (da0) que ya no existe. Ahora el disco está interno, probablemente como ada0 o nvme0ns1.

Montar el sistema de ficheros rw

mount -u -o rw /

Averiguar cómo se llama el disco ahora geom disk list o camcontrol devlist.

geom disk list                                    
Geom name: ada0
Providers:
1. Name: ada0
   Mediasize: 250059350016 (233G)
   Sectorsize: 512
   Mode: r3w3e7
   descr: WDC WDS250G2B0A-00SM50
   lunid: 5001b448b8a2a91f
   ident: 192686806761
   rotationrate: 0
   fwsectors: 63
   fwheads: 16

Cambiar la línea de swap, por ejemplo

/dev/da0p3  none   swap  sw   0   0
 por
/dev/ada0p3  none   swap  sw   0   0

Mejor aún, usar la etiqueta (label) GPT que es independiente del nombre del dispositivo

gpart show -l ada0
=>       40  488397088  ada0  GPT  (233G)
         40     532480     1  efiboot0  (260M)
     532520       1024     2  gptboot0  (512K)
     533544        984        - free -  (492K)
     534528   16777216     3  swap0  (8.0G)
   17311744  471085056     4  zroot-new  (225G)
  488396800        328        - free -  (164K)
ls /dev/gpt/
efiboot0 gptboot0 swap0

En el archivo /etc/fstab usar la etiqueta en lugar del dispositivo

...
/dev/gpt/swap0	  none	  swap	  sw	 0	0
...

Error 2

Import of zpool cache /etc/zfs/zpool.cache failed

El zpool.cache fue generado cuando el pool se llamaba zroot-new y estaba en da0. Ahora el pool se llama zroot y el dispositivo cambió. El caché está obsoleto.

Sencillamente borrarlo, ZFS lo regenera automáticamente

rm /etc/zfs/zpool.cache

Antes de reiniciar para verificar el nombre correcto del dispositivo

swapinfo -h
Device              Size     Used    Avail Capacity
/dev/gpt/swap0      8.0G       0B     8.0G     0%

Si el sistema arrancó pero con errores no críticos Ambos errores no impiden el funcionamiento del sistema. El swap simplemente no está activo hasta que corrijas el fstab, y el zpool.cache se regenera solo. Si llegaste al prompt de login, la migración fue exitosa.

Reiniciar

shutdown -r now

Error 3.

Can't open /dev/gpt/efiboot0

Ese error indica que el bootloader está buscando la partición EFI por su label GPT (efiboot0) pero no la encuentra, probablemente porque el label en el disco nuevo es diferente o no se asignó correctamente

ls /dev/gpt
efiboot0 gptboot0 swap0

Montar el sistema de ficheros rw

mount -u -o rw /

Solución. Renombrar el label al esperado

...
/dev/gpt/efiboot0    /boot/efi	  msdosfs    rw	   2	2
...

Corregir el label

gpart modify -i 1 -l efiboot0 ada0

Si la partición EFI estaba vacía, reinstalar loader

newfs_msdos -F 32 -c 1 /dev/ada0p1
mount -t msdosfs /dev/ada0p1 /mnt
mkdir -p /mnt/EFI/BOOT
cp /boot/loader.efi /mnt/EFI/BOOT/BOOTX64.EFI

umount /mnt

 

FreeBSD es genial!.

lunes, 19 de enero de 2026

Crear conjunto de datos cifrado ZFS NFSv4 (tls)

Conjunto de datos cifrado

=> Cifrado NFS sobre TLS <=

En el servidor (tormenta.local.com)

Crear el keyfile para cifrado automático

Generar un keyfile seguro de 32 bytes (requerido para keyformat=raw):

dd if=/dev/urandom of=/etc/zfs/secifrado.key bs=32 count=1
chmod 400 /etc/zfs/secifrado.key

Este archivo contiene la clave binaria. Respaldar en un lugar seguro, su pérdida implica perder permanentemente el acceso al dataset.

Creación del dataset padre ZFS (no cifrado)

zfs create -o mountpoint=/nfsv4 zroot/nfsv4

A continuación crear el dataset hijo cifrado

zfs create -o encryption=aes-256-gcm -o \
keyformat=raw -o keylocation=file:///etc/zfs/secifrado.key -o \
mountpoint=/nfsv4/secifrado zroot/nfsv4/secifrado

Utiliza AES-256-GCM (recomendado por seguridad y rendimiento). El comando cargará la clave automáticamente durante la creación.

Verificar con el comando siguiente

zfs get encryption,keyformat,keylocation,mountpoint zroot/nfsv4/secifrado
NAME                   PROPERTY     VALUE                          SOURCE
zroot/nfsv4/secifrado  encryption   aes-256-gcm                    -
zroot/nfsv4/secifrado  keyformat    raw                            -
zroot/nfsv4/secifrado  keylocation  file:///etc/zfs/secifrado.key  local
zroot/nfsv4/secifrado  mountpoint   /nfsv4/secifrado               local

Configurar el desbloqueo automático en el arranque

Script rc.d personalizado que cargará la clave y montará el dataset después de importar los pools ZFS, pero antes de iniciar los servicios NFS (evita la intervención manual)

vim /usr/local/etc/rc.d/zfskeys
#############################################################
#!/bin/sh

# PROVIDE: zfskeys
# REQUIRE: zfs
# BEFORE: mountd
# KEYWORD: 

. /etc/rc.subr

name=zfskeys
rcvar=zfskeys_enable
start_cmd="${name}_start"

zfskeys_start() {
    zfs load-key zroot/nfsv4/secifrado
    zfs mount -a  # Montar cualquier dataset despues de cargar la clave
}

load_rc_config $name
run_rc_command "$1"
#############################################################

Convertir el archivo en ejecutable y habilitarlo

chmod +x /usr/local/etc/rc.d/zfskeys
sysrc zfskeys_enable="YES"

Esto permite que la clave se cargue desde el keyfile automáticamente al arranque, asumiendo que zroot raíz no está cifrado y el keyfile es accesible al inicio.

En caso de que zroot esté cifrado, ajustar el keyfile a un dataset no cifrado.

Archivo /etc/exports

#############################################################
V4: /nfsv4 -tls
---
/nfsv4/docs 	    -maproot=root -network 192.168.88.0/24
/nfsv4/secifrado    -maproot=root 192.168.88.51
---
#############################################################

Recargar configuración y reiniciar servicios

service mountd reload
service nfsd restart
service tlsservd restart

En el cliente (solaris.local.com)

service tlsclntd restart

Montar el recurso compartido NFSv4 con tls

mkdir /nizs4
mount -t nfs -o nfsv4,tls tormenta:/secifrado /nizs4

Montaje automático agregar en /etc/fstab

tormenta:/secifrado  /nizs4   nfs   rw,nfsv4,tls,noatime,bg   0  0

Seguridad: El keyfile permite desbloqueo sin intervención, mejor proteger (permisos 400, backups). Si el servidor es sustraido, el keyfile en disco permite acceso, considera almacenarlo en un dispositivo externo removible.

Reiniciar el servidor, comprobar que el dataset está montado y accesible via NFS desde el cliente.

Si TLS falla, comprobar logs (dmesg | grep tls, /var/log/messages). Verificar que los puertos NFS (2049/TCP) están abiertos en el firewall PF. Para depuración usar mount -vv

zfs mount | grep "secifrado" 
nfsstat -m
---
tormenta:/secifrado on /nizs4
nfsv4,minorversion=2,tcp,resvport,tls,nconnect=1,hard,cto,sec=sys,acdirmin=3,\
acdirmax=60,acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,\
wsize=65536,readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,\
retrans=2147483647
---

Archivo /etc/exports

V4: /nfsv4 -tls
...
/nfsv4/secifrado     -maproot=root 192.168.88.51
FreeBSD es genial!.

sábado, 13 de diciembre de 2025

NFS sobre TLS FreeBSD 14.3

Configurar Cifrado NFS sobre TLS


El tráfico NFS está cifrado. Autenticación sigue siendo AUTH_SYS (UID/GID)

NFS sobre TLS proporciona cifrado en tránsito (cifrado del tráfico RPC/TLS) sin necesidad de Kerberos. Utiliza certificados X.509 (pueden ser auto-firmados para entornos locales).

Preparación (en el servidor y cliente) Resolución DNS correcta (tormenta.local.com -> 192.168.88.160)
El kernel en FreeBSD 14.3 soporta KTLS (está en Generic desde FreeBSD 13+)


En ambos dos editar /etc/rc.conf para habilitar los daemons TLS:

tlsservd_enable="YES"  # Demonio servidor TLS (necesario para mounts TLS)
tlsclntd_enable="YES"  # Demonio cliente TLS


En el servidor tormenta.local.com - 192.168.88.160


Instalar y configurar Unbound en el servidor


Generación y Colocación de Certificados


Generar los certificados y moverlos a la carpeta que tlsservd exige por defecto.

Crear directorio temporal para trabajar

mkdir -p /root/certs-work
cd /root/certs-work

Crear CA

openssl genrsa -out ca.key 4096
openssl req -new -x509 -days 3650 -key ca.key -out ca.crt -subj "/CN=HomeLabRootCA"

Crear Certificado Servidor (tormenta)

openssl genrsa -out server.key 4096
openssl req -new -key server.key -out server.csr -subj "/CN=tormenta.local.com"
openssl x509 -req -days 3650 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt

Crear Certificado Cliente (solaris) - se usará luego

openssl genrsa -out client.key 4096
openssl req -new -key client.key -out client.csr -subj "/CN=solaris.local.com"
openssl x509 -req -days 3650 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 02 -out client.crt

Instalacion en rutas por defecto del servidor


Crear el directorio

mkdir /etc/rpc.tlsservd

Copiar archivos con los nombres que FreeBSD espera:

cp server.crt /etc/rpc.tlsservd/cert.pem
cp server.key /etc/rpc.tlsservd/certkey.pem
cp ca.crt     /etc/rpc.tlsservd/cacert.pem

Crear lista de revocación vacía (necesaria por defecto)

touch /etc/rpc.tlsservd/crl.pem

Permisos estrictos

chmod 700 /etc/rpc.tlsservd
chmod 600 /etc/rpc.tlsservd/certkey.pem
chmod 444 /etc/rpc.tlsservd/cert.pem
chmod 444 /etc/rpc.tlsservd/cacert.pem

En el cliente (solaris.local.com) IP 192.168.88.51


Preparar directorios y certificados

mkdir /etc/rpc.tlsclntd

Copiar los archivos generados en tormenta hacia solaris y renombrarlos

scp tormenta.local.com:/root/certs-work/client.crt /etc/rpc.tlsclntd/cert.pem
scp tormenta.local.com:/root/certs-work/client.key /etc/rpc.tlsclntd/certkey.pem
scp tormenta.local.com:/root/certs-work/ca.crt /etc/rpc.tlsclntd/cacert.pem

Aplicar permisos estrictos

chmod 700 /etc/rpc.tlsclntd
chmod 600 /etc/rpc.tlsclntd/certkey.pem
chmod 444 /etc/rpc.tlsclntd/cert.pem
chmod 444 /etc/rpc.tlsclntd/cacert.pem
chmod 644 /etc/rpc.tlsclntd/crl.pem

client.crt Es el certificado público del cliente. Identifica quién es el cliente. client.key Es la clave privada del cliente. Nunca debe compartirse. Sirve para firmar la comunicación. cacert.pem Es el certificado de la Autoridad Certificadora. Sirve para que el cliente verifique que el servidor es confiable.

Es importante saber que cambiar la extensión del archivo no cambia su contenido, pero ayuda al software a entender qué formato esperar.

PEM (Privacy Enhanced Mail): Es el formato estándar de texto (Base64) que empieza con 
-----BEGIN CERTIFICATE-----

Verificar que la Clave Privada y el Certificado coinciden

Este es el paso más crítico. Ambos archivos deben tener el mismo "Módulo" (un identificador matemático único). Si los códigos hash que obtienes son idénticos, son pareja.

Ejecuta estos dos comandos:

# Extraer el módulo del certificado público
openssl x509 -noout -modulus -in cert.pem | openssl md5

# Extraer el módulo de la clave privada
openssl rsa -noout -modulus -in certkey.pem | openssl md5

Resultado esperado: Ambos comandos deben devolver exactamente la misma cadena de caracteres (ej. (stdin)= 68b19a0d...). Si son diferentes, esa clave no pertenece a ese certificado.

Verificar que el Certificado fue firmado por la CA

Ahora comprobaremos la cadena de confianza. Queremos confirmar que cert.pem es "hijo" legítimo de cacert.pem. Ejecutando

openssl verify -CAfile cacert.pem cert.pem
cert.pem: OK

Resultado esperado: Deberías ver un mensaje final que diga: cert.pem: OK

Comprobar validez de las fechas

openssl x509 -noout -dates -in cert.pem
notBefore=Dec  9 20:38:11 2025 GMT
notAfter=Dec  7 20:38:11 2035 GMT

Crear lista de revocación vacía (necesaria por defecto)

touch /etc/rpc.tlsservd/crl.pem

Modificar /etc/exports para requerir TLS

Solo la linea V4: puede tener opciones de seguridad.

V4: /nfsv4 -tls
/nfsv4/dellhome		-maproot=root -network 192.168.88.0/24
/nfsv4/poolrecovery 	-maproot=root -network 192.168.88.0/24
/nfsv4/docs 		-maproot=root -network 192.168.88.0/24
/nfsv4/confsolaris 	-maproot=root -network 192.168.88.0/24
/nfsv4/conftormenta 	-maproot=root -network 192.168.88.0/24

Aplicar cambios

service nfsuserd restart
service mountd restart
service nfsd restart

Cliente solaris.local.com (192.168.88.51)


Montar con TLS (temporal)

mount -t nfs -o nfsv4,tls tormenta.local.com:/docs /punto/de/montaje

Permanente (en /etc/fstab)

...
# nfs
tormenta:/poolrecovery    /nisc4    nfs     rw,nfsv4,tls,noatime,bg    	0  	0
tormenta:/confsolaris     /nics4    nfs     rw,nfsv4,tls,noatime,bg	0  	0
tormenta:/docs            /nids4    nfs     rw,nfsv4,tls,noatime,bg    	0  	0
tormenta:/dellhome 	  /nihs4    nfs     ro,nfsv4,tls,noatime,bg	0  	0
mount -a

Servidor - configuración de servicios /etc/rc.conf


NFS y RPC

nfs_server_enable="YES"
nfsv4_server_enable="YES"
nfsuserd_enable="YES"

TLS demonio (servidor)

sysrc tlsservd_enable="YES"

Habilitar Kernel TLS

sysctl kern.ipc.tls.enable=1
echo 'kern.ipc.tls.enable=1' >> /etc/sysctl.conf

Recomendación: La seguridad debe ser en capas (Defensa en profundidad): Firewall + Restricción de IP NFS + Certificados TLS.

sysrc statd_enable="YES"   # Para bloqueo de archivos (opcional pero recomendado)
sysrc lockd_enable="YES    # Para bloqueo de archivos 
sysrc mountd_flags="-r"    # Recarga automatica al compartir datasets

Iniciar servicios

service tlsservd start
service nfsuserd restart
service mountd restart
service nfsd restart

Cliente (solaris.local.com) Configuración (/etc/rc.conf)

nfs_client_enable="YES"
nfsv4_client_enable="YES"
nfsuserd_enable="YES"

# TLS demonio (cliente)
tlsclntd_enable="YES"

Iniciar servicios

service nfsclient start
service nfsuserd start

Habilitar Kernel TLS

sysctl kern.ipc.tls.enable=1
echo 'kern.ipc.tls.enable=1' >> /etc/sysctl.conf

Iniciar cliente

service nfsuserd start
service tlsclntd start

Prueba de montaje

mkdir -p /mnt/docs
mount -t nfs -o nfsv4,tls 192.168.88.160:/docs /mnt/docs

Verificar cifrado

root@solaris:~# nfsstat -m
tormenta:/docs on /nids4
nfsv4,minorversion=2,tcp,resvport,tls,nconnect=1,hard,cto,sec=sys,acdirmin=3,acdirmax=60,acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2147483647

Debe aparecer tls en las banderas (flags)

nfsstat -m
root@solaris:~# nfsstat -m
tormenta:/poolrecovery on /nisc4
nfsv4,minorversion=2,tcp,resvport,tls,nconnect=1,hard,cto,sec=sys,acdirmin=3,acdirmax=60,acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2147483647

tormenta:/confsolaris on /nics4
nfsv4,minorversion=2,tcp,resvport,tls,nconnect=1,hard,cto,sec=sys,acdirmin=3,acdirmax=60,acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2147483647

tormenta:/docs on /nids4
nfsv4,minorversion=2,tcp,resvport,tls,nconnect=1,hard,cto,sec=sys,acdirmin=3,acdirmax=60,acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2147483647

tormenta:/dellhome on /nihs4
nfsv4,minorversion=2,tcp,resvport,tls,nconnect=1,hard,cto,sec=sys,acdirmin=3,acdirmax=60,acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2147483647

Regla simple:

tlsservd (TLS Server Daemon): Es para la máquina que OFRECE los archivos (el Servidor). Escucha las peticiones de cifrado entrantes.
tlsclntd (TLS Client Daemon): Es para la máquina que MONTA los archivos (el Cliente). Inicia la petición de cifrado hacia afuera.

Verificar con tcpdump que el tráfico NFS sobre TLS está cifrado

Una vez que el montaje NFS con TLS funciona correctamente, se puede confirmar que el tráfico está realmente cifrado ejecutando tcpdump en el servidor o en el cliente.

Comando básico (en servidor)

tcpdump -i re0 -nn port 2049

O más específico, ver sólo NFS

tcpdump -i re0 -nn port 2049 and host 192.168.88.51

Qué esperar

Si TLS está funcionado correctamente - cifrado activo Verás paquetes TCP en el puerto 2049 Después del handshake TLS inicial, todo el payload de los paquetes estará cifrado.

...
13:35:28.349050 IP 192.168.88.160.2049 > 192.168.88.51.773: Flags [P.], seq 469255:469785, ack 251188, win 29128, options [nop,nop,TS val 505937474 ecr 417283551], length 530
13:35:28.349301 IP 192.168.88.51.773 > 192.168.88.160.2049: Flags [.], ack 469785, win 4344, options 
...

No verás texto legible como nombre de archivos, rutas, ni datos de ficheros. Todo será binario cifrado.

Ejemplo típico de texto claro

NFS request xid ... read fh .../poolrecovery/backup-2025-12-10.gz offset 0 count 32768
Comando más detallado para ver el handshake TLS
tcpdump -i re0 -nn -s 0 -A port 2049
-i <interfaz>
-A imprime cada paquete en formato ASCII (crucial para leer contenido)
-n No convierte direcciones IP a nombres de host (más rápido)

En el cliente solaris echo 'Garantizar cifrado' > /nids4/prueba.txt no podrás ver ni el nombre del archivo ni su contenido.

...
14:10:09.830256 IP 192.168.88.160.2049 > 192.168.88.51.890: Flags [P.], seq 1:115, ack 162, win 29128, options [nop,nop,TS val 3871689747 ecr 1810578769], length 114
E....V..@.....X...X3...z.C........q.2......
...
tcpdump -i re0 -nn port 2049 -c 50

Genera activida en el cliente solaris

ls -ltr /nihs4
...
14:12:35.627829 IP 192.168.88.160.2049 > 192.168.88.51.698: Flags [.], ack 230, win 29128, options [nop,nop,TS val 1928012123 ecr 3657311778], length 0
14:12:35.628036 IP 192.168.88.160.2049 > 192.168.88.51.698: Flags [P.], seq 1:303, ack 230, win 
...

Si solo ves números de secuencia y longitudes, sin nombres de archivos -> cifrado Si ves rutas y operaciones NFS -> sin cifrado (TLS inactivo).

FreeBSD es genial!.

martes, 15 de abril de 2025

Script sh Replicar Instantáneas de Conjunto de Datos ZFS desde Servidor FreeBSD Local a otra Máquina FreeBSD Externa

Fuente:

https://www.iceflatline.com/2015/07/using-zfs-replication-features-in-freebsd-to-improve-my-offsite-backups/

El autor de este sencillo e ingenioso guión es iceflatline. Contiene algunas modificaciones para adaptarlo a este laboratorio

https://gnulinuxcodigo.blogspot.com/2025/03/crear-particiones-en-disco-duro-usb-con.html

Crear el pool de respaldo zbackup

 zpool create -o ashift=12 \
-O compression=lz4 \
-O atime=off \
-O mountpoint=none \
backup /dev/gpt/zbackup

Conjuntos de datos zbackup

 sudo zfs create -o mountpoint=none zbackup/solaris
 sudo zfs create -o mountpoint=none zbackup/solaris/home
 sudo zfs create -o mountpoint=none zbackup/solaris/home/carlos
 sudo zfs create -o mountpoint=none zbackup/tormenta-confiles
 sudo zfs create -o mountpoint=none zbackup/usr/
 sudo zfs create -o mountpoint=none zbackup/usr/backup
 sudo zfs create -o mountpoint=none zbackup/usr/backup/docs
 sudo zfs create -o mountpoint=none zbackup/usr/home

Flujo de trabajo recomendado para un disco de respaldo mountpoint=none

Seguridad contra modificaciones accidentales

Evita conflictos de rutas

Comportamiento en el arranque — Con mountpoint=none ZFS no intenta montar nada del pool zbackup al arrancar, lo que acelera el boot y evita errores si el disco USB no está conectado en ese momento.

Acceso bajo demanda — Cuando se necesita recuperar algo, se monta puntualmente el dataset de interés, se hace lo que se necesita, y luego se desmonta.

Los scripts no se ven afectados — zfs receive escribe directamente al dataset sin necesidad de que esté montado. mountpoint=none no interfiere en absoluto con zfs send/receive.

carlos@tormenta:~ % zfs list -r zbackup
zbackup                            48.9G  1.71T  4.86M  none
zbackup/solaris                    40.8G  1.71T    96K  none
zbackup/solaris/home               40.8G  1.71T    96K  none
zbackup/solaris/home/carlos        40.8G  1.71T  39.9G  none
zbackup/tormenta-confiles           800K  1.71T   800K  none
zbackup/usr                        8.16G  1.71T   104K  none
zbackup/usr/backup                 7.80G  1.71T   104K  none
zbackup/usr/backup/docs            7.80G  1.71T  7.80G  none
zbackup/usr/home                    368M  1.71T   132M  none
#!/bin/sh
### BEGIN INFO
# PROVIDE:
# REQUIRE:
# KEYWORD:

### INICIO DEL GUION
# Estas variables se nombran primero porque están anidadas en otras variables.
snap_prefix=snap
retention=15

# Se necesitan rutas completas a estas utilidades al ejecutar el script desde \
cron.
date=/bin/date
grep=/usr/bin/grep
sed=/usr/bin/sed
sort=/usr/bin/sort
xargs=/usr/bin/xargs
zfs=/sbin/zfs

src_0="zroot/home/carlos"
dst_0="zbackup/solaris/home/carlos"
host="root@192.168.88.160"

# Usar $date en lugar de date para consistencia con rutas absolutas.
today="$snap_prefix-`$date +%Y%m%d`"
yesterday="$snap_prefix-`$date -v -1d +%Y%m%d`"
snap_today="$src_0@$today"
snap_yesterday="$src_0@$yesterday"

# Patrón grep con sufijo numérico para evitar falsos positivos.
snap_old=`$zfs list -t snapshot -o name \
  | $grep "${src_0}@${snap_prefix}-[0-9]" \
  | $sort -r \
  | $sed 1,${retention}d \
  | $sort \
  | $xargs -n 1`

log=/home/carlos/cronlog

# Todo el pipeline de listado remoto corre en tormenta vía SSH.
snap_old_dst_0=`ssh $host "$zfs list -t snapshot -o name \
  | grep '${dst_0}@${snap_prefix}-[0-9]' \
  | sort -r \
  | sed 1,${retention}d \
  | sort"`

# Crea una línea en blanco entre la entrada de registro anterior y esta.
echo >> $log

# Imprimir el nombre del script.
echo "zfsrep.sh" >> $log
# Imprime la fecha de hoy.
$date >> $log
# Crea una línea en blanco.
echo >> $log

# Buscar instantánea de hoy y, si no la encuentra, créala.
if $zfs list -H -o name -t snapshot \
  | $sort \
  | $grep "${snap_today}$" > /dev/null
then
	echo "La instantánea de hoy '$snap_today' ya existe." >> $log
else
	echo "Tomando la instantánea de hoy: $snap_today" >> $log
	$zfs snapshot -r $snap_today >> $log 2>&1
fi

echo >> $log

# Replicar el snapshot diario (ayer) o mostrar error si falta.
if $zfs list -H -o name -t snapshot \
  | $sort \
  | $grep "${snap_yesterday}$" > /dev/null
then
	echo "La instantánea de ayer '$snap_yesterday' existe. Continuando \
    con la replicacion..." >> $log
	$zfs send -R -i $snap_yesterday $snap_today \
	  | ssh $host $zfs receive -vuF -x mountpoint $dst_0 >> $log 2>&1
	echo >> $log
	echo "Replicacion completada." >> $log
else
	echo "Error: Replicacion no completada. Falta la instantánea de \
    ayer." >> $log
fi

echo >> $log

# Eliminar instantáneas locales más antiguas que el valor asignado a retention.
echo "Intentando destruir instantáneas antiguas $src_0..." >> $log

if [ -n "$snap_old" ]
then
	echo "Destruyendo las siguientes instantáneas antiguas:" >> $log
	echo "$snap_old" >> $log
	$zfs list -t snapshot -o name \
	  | $grep "${src_0}@${snap_prefix}-[0-9]" \
	  | $sort -r \
	  | $sed 1,${retention}d \
	  | $sort \
	  | $xargs -n 1 $zfs destroy -r >> $log 2>&1
else
	echo "No se pudo encontrar ninguna instantánea local para \
    destruir." >> $log
fi

echo >> $log

# Purgar snaps remotos > retention
# Todo el pipeline, incluido zfs destroy, corre en tormenta vía SSH.
echo "Intentando destruir instantáneas antiguas $dst_0..." >> $log

if [ -n "$snap_old_dst_0" ]
then
	echo "Destruyendo las siguientes instantáneas antiguas en $host:" >> $log
	echo "$snap_old_dst_0" >> $log
	ssh $host "$zfs list -t snapshot -o name \
	  | grep '${dst_0}@${snap_prefix}-[0-9]' \
	  | sort -r \
	  | sed 1,${retention}d \
	  | sort \
	  | xargs -n 1 $zfs destroy -r" >> $log 2>&1
else
	echo "No se pudo encontrar ninguna instantánea remota para \
    destruir." >> $log
fi

# Marcar el fin del script con un delimitador.
echo "**********" >> $log

### FIN DEL SCRIPT

Luego, agregue una tarea a la tabla cron bajo la cuenta del usuario. El script se ejecuta todos los días a las 22:00 (hora local):

# Ejecuta script backup cada día a las 22:00
0 22 * * * /home/carlos/bin/zfsrep.sh

Las entradas del archivo /home/carlos/cronlog se verán así:

**********

zfsrep.sh
Tue Apr 15 09:45:19 CEST 2025

Tomando la instantánea de hoy: zroot/home@snap-20250415

La instantánea de ayer 'zroot/home@snap-20250414' existe. \
Continuando con la replicacion...
receiving incremental stream of zroot/home@snap-20250415 into \
zbackup/solaris/home/carlos@snap-20250415
received 312B stream in 0.91 seconds (341B/sec)
receiving incremental stream of zroot/home/carlos@snap-20250415 \
into zbackup/solaris/home/carlos@snap-20250415
received 16.3M stream in 7.07 seconds (2.30M/sec)

Replicacion completada.

Intentando destruir instantáneas antiguas zroot/home...
Destruyendo las siguientes instantáneas antiguas:
zroot/home@snap-20250327

Intentando destruir instantáneas antiguas zbackup/solaris...
No se pudo encontrar ninguna instantánea para destruir.
FreeBSD es genial!.

martes, 31 de enero de 2023

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!.

viernes, 21 de octubre de 2022

ZFS Cifrar Conjunto de Datos Dataset FreeBSD

https://www.oracle.com/technical-resources/articles/solaris/how-to-manage-zfs-encryption.html

ZFS Datasets Encriptados

Resultado de shell que muestra la lista de conjuntos de datos

$ zfs list


NAME                                           USED  AVAIL     REFER  MOUNTPOINT
zroot                                         14.1G   420G       96K  /zroot
zroot/ROOT                                    12.1G   420G       96K  none
zroot/ROOT/13.1-RELEASE-p2_2022-10-19_233328     8K   420G     2.63G  /
zroot/ROOT/13.1-RELEASE_2022-10-19_232051        8K   420G     1.33G  /
zroot/ROOT/default                            12.1G   420G     11.4G  /
zroot/encrypt                                   96K  30.0G       96K  /zroot/encrypt
zroot/tmp                                      288K   420G      152K  /tmp
zroot/usr                                     1.97G   420G       96K  /usr
zroot/usr/home                                 350M   420G      308M  /usr/home
zroot/usr/ports                                912M   420G      912M  /usr/ports
zroot/usr/src                                  759M   420G      759M  /usr/src
zroot/var                                     1.16M   420G       96K  /var
zroot/var/audit                                 96K   420G       96K  /var/audit
zroot/var/crash                                 96K   420G       96K  /var/crash
zroot/var/log                                  592K   420G      384K  /var/log
zroot/var/mail                                 200K   420G      144K  /var/mail
zroot/var/tmp
104K   420G       96K  /var/tmp

Listar snapshots

$ zfs list -t snapshot


NAME                                                              USED  AVAIL     REFER  MOUNTPOINT
zroot@baseMateKdeInstall                                            0B      -       96K  -
zroot/ROOT@baseMateKdeInstall                                       0B      -       96K  -
zroot/ROOT/13.1-RELEASE-p2_2022-10-19_233328@baseMateKdeInstall     0B      -     2.63G  -
zroot/ROOT/13.1-RELEASE_2022-10-19_232051@baseMateKdeInstall        0B      -     1.33G  -
zroot/ROOT/default@2022-10-19-23:20:51-0                         77.8M      -     1.33G  -
zroot/ROOT/default@2022-10-19-23:33:28-0                         34.2M      -     2.63G  -
zroot/ROOT/default@baseMateKdeInstall                             533M      -     11.9G  -
zroot/tmp@baseMateKdeInstall                                      136K      -      168K  -
zroot/usr@baseMateKdeInstall                                        0B      -       96K  -
zroot/usr/home@baseMateKdeInstall                                41.3M      -      224M  -
zroot/usr/ports@baseMateKdeInstall                                  8K      -      912M  -
zroot/usr/src@baseMateKdeInstall                                    8K      -      759M  -
zroot/var@baseMateKdeInstall                                        0B      -       96K  -
zroot/var/audit@baseMateKdeInstall                                  0B      -       96K  -
zroot/var/crash@baseMateKdeInstall                                  0B      -       96K  -
zroot/var/log@baseMateKdeInstall                                  208K      -      336K  -
zroot/var/mail@baseMateKdeInstall                                  56K      -      144K  -
zroot/var/tmp@baseMateKdeInstall                                    8K      -       96K  -


Creación y uso de conjuntos de datos cifrados, ejemplo simple de habilitación del cifrado.

Administrar claves de cifrado localmente. Si no especifica ninguna política de administración de claves, ZFS solicitará interactivamente una frase de contraseña. Esto probablemente no es ideal en la mayoría de las implementaciones de centros de datos, por lo que en su lugar necesitamos obtener la clave a través de medios no interactivos desde otro lugar. La clave de ajuste puede ser una frase de contraseña o una clave AES sin procesar. El método no interactivo más simple es almacenar la clave de ajuste o frase de contraseña en un archivo y decirle a ZFS qué archivo buscar para esa clave. Si utiliza este método, se supone que el otro sistema de archivos es suficientemente seguro por otros medios, como estar en un disco extraíble. La clave de ajuste solo es necesaria en el momento en que el sistema de archivos ZFS se monta inicialmente después del arranque del sistema, por lo que los medios extraíbles se pueden quitar más tarde si es necesario.


 $ zfs create -o encryption=on -o keylocation=prompt -o \
 keyformat=passphrase zroot/encrypt
Enter new passphrase:
Re-enter new passphrase:

Zfs Listar el dataset zroot/encrypt


 $ zfs list zroot/encrypt 
NAME            USED  AVAIL     REFER  MOUNTPOINT
zroot/encrypt   200K   420G      200K  /zroot/encrypt

Crear un archivo dentro del dataset


 $ touch /zroot/encrypt/supersecret

Zfs creación del conjunto de datos con una cuota


 $ zfs set quota=30g zroot/encrypt

Zfs obtener encryption


 $ zfs get encryption zroot/encrypt 
NAME           PROPERTY    VALUE        SOURCE
zroot/encrypt  encryption  aes-256-gcm  -

Zfs desmontar dataset


 $ zfs unmount zroot/encrypt

Zfs descargar llave


 $ zfs unload-key -r zroot/encrypt 
1 / 1 key(s) successfully unloaded

No se monta directamente


 $ zfs mount zroot/encrypt 
cannot mount 'zroot/encrypt': encryption key not loaded

Zfs obtener estado actual de la llave


 $ zfs get keystatus zroot/encrypt 
NAME           PROPERTY   VALUE        SOURCE
zroot/encrypt  keystatus  unavailable  -

Zfs cargar llave


 $ zfs load-key -r zroot/encrypt 
Enter passphrase for 'zroot/encrypt':
1 / 1 key(s) successfully loaded

$ zfs mount -a

Zfs comprobar accesibilidad


 $ ls /zroot/encrypt 
supersecret

$ Zfs listar


 $ zfs list
NAME                                           USED  AVAIL     REFER  MOUNTPOINT
zroot                                         14.1G   420G      104K  /zroot
zroot/ROOT                                    12.1G   420G       96K  none
zroot/ROOT/13.1-RELEASE-p2_2022-10-19_233328     8K   420G     2.63G  /
zroot/ROOT/13.1-RELEASE_2022-10-19_232051        8K   420G     1.33G  /
zroot/ROOT/default                            12.1G   420G     11.4G  /
zroot/encrypt                                  200K  30.0G      200K  /zroot/encrypt
zroot/tmp                                      288K   420G      152K  /tmp
zroot/usr                                     1.98G   420G       96K  /usr
zroot/usr/home                                 359M   420G      315M  /usr/home
zroot/usr/ports                                912M   420G      912M  /usr/ports
zroot/usr/src                                  759M   420G      759M  /usr/src
zroot/var                                     1.16M   420G       96K  /var
zroot/var/audit                                 96K   420G       96K  /var/audit
zroot/var/crash                                 96K   420G       96K  /var/crash
zroot/var/log                                  592K   420G      384K  /var/log
zroot/var/mail                                 200K   420G      144K  /var/mail
zroot/var/tmp                                  104K   420G       96K  /var/tmp

Zfs desmontar, listar, keystatus, load-key, mount, unmount.


$ zfs unmount zroot/encrypt
 $ zfs unload-key -r zroot/encrypt 
1 / 1 key(s) successfully unloaded
$ ls /zroot/encrypt $ zfs get keystatus zroot/encrypt NAME PROPERTY VALUE SOURCE zroot/encrypt keystatus unavailable -
$ zfs load-key -r zroot/encrypt Enter passphrase for 'zroot/encrypt': 1 / 1 key(s) successfully loaded
$ zfs get keystatus zroot/encrypt NAME PROPERTY VALUE SOURCE zroot/encrypt keystatus available -
$ zfs mount -a $ ls /zroot/encrypt supersecret
$ zfs unmount zroot/encrypt $ zfs unload-key -r zroot/encrypt 1 / 1 key(s) successfully unloaded
$ ls /zroot/encrypt

 $ zfs allow -u carlos keychange zroot/encrypt

El ejemplo anterior permite al usuario carlos cambiar el valor de la clave de ajuste para el conjunto de datos y sus elementos secundarios, pero no cambiar la propiedad keysource. En este caso que el usuario carlos no puede montar el conjunto de datos ZFS después del arranque ni puede forzar la descarga del conjunto de datos y su clave. El usuario raíz (y el propio arranque del sistema) tiene todas las delegaciones de ZFS.

Si fuera un disco externo tendríamos que importar el zpool después de un reinicio. Por ejemplo, previamente hemos creado un zpool de nombre cifrado y un conjunto de datos llamado encrypt.


# zfs import -l cifrado/encrypt
Enter passphrase for 'cifrado/encrypt':
1 / 1 keys successfully loaded

 

FreeBSD es genial!.