Instalar Arch Linux 64 bits UEFI KDE Plasma

Instalar Arch Linux x86_64 UEFI KDE Plasma en una máquina virtual.

Nota: En una instalación en disco, la partición raíz no debería ser menor de 50 Gb. Por lo demás el proceso es el mismo.  Con el tamaño actual de los discos esto no es un problema.

Cargar teclado español

# loadkeys es

Listar los dispositivos de bloque del sistema, discos duros, cd-rom, unidades flash, etc.

# lsblk

Particionado con cfdisk

Creamos una primera partición de 20G que será nuestra partición de sitema (root). de tipo linux filesystems.

# cfdisk /dev/sda
   gpt
new 20G  /dev/sda1
type linux filesystems

new 512M /dev/sda2
type Efi Systems

new 4G /dev/sda3
type linux-swap 

new 29G /dev/sda4
type linux filesystems

write quit

# lsblk

Vamos a crear los Sistema de Ficheros y montar particiones

# mkfs.ext4 /dev/sda1

# mount /dev/sda1 /mnt

# mkfs.vfat /dev/sda2

# mkdir -p /mnt/boot/efi

# mount /dev/sda2 /mnt/boot/efi

# mkswap /dev/sda3

# swapon /dev/sda3

# mkfs.ext4 /dev/sda4

# mkdir /mnt/home

# mount /dev/sda4 /mnt/home

# pacstrap /mnt base base-devel grub efibootmgr

# genfstab -U -p /mnt >> /mnt/etc/fstab

# cat /mnt/etc/fstab

Entrar al entorno de instalación

# arch-chroot /mnt /bin/bash

# nano /etc/locale.gen
 es_ES.UTF-8 UTF-8
 es_ES ISO-8859-1

# locale-gen

# echo LANG=es_ES.UTF8-8 > /etc/locale.conf

# echo KEYMAP=es > /etc/vconsole.conf

# ln -sf /usr/share/zoneinfo/Europe/Madrid > /etc/localtime

# echo archlinux > /etc/hostname

# mkinitcpio -p linux

# passwd root

Usuario no priveligiado

# useradd -m -g users -G wheel -s /bin/bash carles

# passwd carles

# grub-mkconfig -o /boot/grub/grub.cfg

# grub-install /dev/sda

# umount /mnt -R

# exit

# exit

# reboot

# ip addr

# systemctl enable dhcpcd

# systemctl start dhcpcd

# ping -c 2 www.freebsd.org

# pacman -S xorg

# pacman -S xterm xorg-xclock xorg-twm xorg-xinit xorg-server-utils

# pacman -S plasma kdebase

# pacman -S ttf-freefont ttf-linux-libertine-g artwiz-fonts

# pacman -S ttf-ubuntu-font-family cantarell-fonts freetype2

# pacman -S ttf-droid ttf-linux-libertine ttf-liberation

# pacman -S ttf-fira-mono ttf-fira-sans ttf-gentium fontsproto

# pacman -S ttf-dejavu noto-fonts font-bitstream-speedo

# systemctl enable sddm

# reboot

Intercambiar teclado es y us con la combinación de teclas alt-shift

$ cat /etc/X11/xorg.conf.d/10-keyboard.conf

Section "InputClass"
        Identifier "system-keyboard"
        MatchIsKeyboard "on"
        Option "XkbLayout"  "es,us"
        Option "XkbModel"   "pc104"
        Option "XkbVariant" "deadtilde,"
        Option "XkbOptions" "grp:alt_shift_toggle"
EndSection

# pacman -S libreoffice libreoffice-es

# pacman -S kdegraphics-okular firefox firefox-i18n-es-es

# pacman -S vlc gimp k3b kaffeine gparted spectacle


Unix es genial!.

Cifrar particion con cryptsetup luks

Sistema Operativo Arch Linux

# lsmod|grep dm_crypt
dm_crypt               28672  1
dm_mod                102400  2 dm_crypt

Si no aparece el módulo lo cargamos con:
# modprobe dm_crypt

Ya creada la partición /dev/sda5, procedemos a formatear usando el sistema de archivos LUKS (Linux Unified Key Setup)

# cryptsetup luksFormat /dev/sda5

El UUID del nuevo sistema de ficheros encryptado.

# cryptsetup luksUUID /dev/sda5
2005190e-81e8-4292-a84e-e84a06d6d70a

El siguiente paso es mapear el sistema de ficheros contra encrypted-fs e introducir la contraseña que necesitaremos recordar.

# cryptsetup luksOpen /dev/sda5 encrypted-fs
Enter passphrase for /dev/sda5

Tendrá que darle formato y montar:

# mkfs.ext4 /dev/mapper/encrypted-fs
mke2fs 1.43.3 (04-Sep-2016)
Creating filesystem with 10521856 4k blocks and 2632672 inodes
Filesystem UUID: 8da03053-b6bd-4add-b944-713fa2942806
Superblock backups stored on blocks: 
        32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208, 
        4096000, 7962624

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (65536 blocks): done
Writing superblocks and filesystem accounting information: done 

Esta es la salida de fdisk

# fdisk -l
Disk /dev/sda: 465.8 GiB, 500107862016 bytes, 976773168 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes
Disklabel type: gpt
Disk identifier: 9E0ED2FC-0BC1-4542-9688-DF733F20A984

Device         Start       End   Sectors  Size Type
/dev/sda1       2048 104859647 104857600   50G Linux filesystem
/dev/sda2  104859648 105908223   1048576  512M EFI System
/dev/sda3  105908224 114296831   8388608    4G Linux swap
/dev/sda4  114296832 533727231 419430400  200G Linux filesystem
/dev/sda5  533727232 617906175  84178944 40.1G Linux filesystem



Disk /dev/mapper/encrypted-fs: 40.1 GiB, 43097522176 bytes, 84174848 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

La salida del comando siguiente nos sirve para averiguar el UUID y utilizarlo en fstab:

# tune2fs -l /dev/mapper/encrypted-fs | grep UUID

Filesystem UUID:          8da03053-b6bd-4add-b944-713fa2942806

# mkdir /encrypted-fs

Lo añadimos al archivo /etc/fstab con la opción noauto para iniciar y montar manualmente.

# /dev/sda5                                                                                                   
UUID=8da03053-b6bd-4add-b944-713fa2942806   /encrypted-fs  ext4  noauto,defaults  0 0

# cat /etc/fstab

Si quiere montar el sistema de archivos cifrado al iniciar el sistema, tiene que agregar al archivo /etc/crypttab la línea, le pedirá la contraseña al arranque del sistema.

encrypted-fs  /dev/mapper/encrypted-fs  none

Antes de desconectar el dispositivo vamos a copiar los datos que queremos mantener cifrados:

# cp -r /home/carles/gentoo /encrypted-fs/

Desmontamos el dispositivo antes de desconectarlo
# umount /encrypted-fs/

Ya podemods desconectar el dispositivo ejecutando cryptsetup, con la opción luksClose y el nombre del dispositivo.

# cryptsetup luksClose /dev/mapper/encrypted-fs

Bien, reiniciar el sistema.

Al reiniciar el sistema tendremos que cargar el módulo con lsmod, y abrirlo con cryptsetup y la opción luksOpen /dev/sda5 encrypted-fs. Nos pedirá la frase o contraseña introducida para el cifrado de la partición.

# cryptsetup luksOpen /dev/sda5 encrypted-fs
Enter passphrase for /dev/sda5:

Aún no podremos acceder al dispositivo, tenemos que montarlo:

# ls /encrypted-fs/gentoo
ls: cannot access '/encrypted-fs/gentoo': No such file or directory

# mount /encrypted-fs

# ls /encrypted-fs
gentoo  lost+found

Unix es genial!.

Implementar Wordress con docker-compose

La creación de un nuevo entorno de alojamiento web puede llevar mucho tiempo, especialmente si tiene que hacerlo a menudo. Docker Compose, después de la configuración inicial, simplifica el proceso de instalación en un solo comando de implementación reduciendo el tiempo y el esfuerzo necesarios.

Docker es una plataforma recipiente que permite la instalación de software simple y rápida en cualquier sistema o sistema operativo. Se envuelve la pieza de software en un sistema de archivos completo que incluye todo lo que necesita para funcionar como el código, herramientas del sistema y las bibliotecas. Esto permite que cualquiera pueda empaquetar una aplicación con sus dependencias en un bloque de construcción estandarizada.

Install Docker en una máquina Linux (Ubuntu 16.04).

Utilizar Docker Compose requiere tener el demonio Docker corriendo en su máquina local o servidor en la nube. Instalar Docker es fácil:

# wget -qO- https://test.docker.com/ | sh

Añadir el usuario al grupo docker
# usermod -aG docker carles

Activar el reenvío de paquetes

# echo “1” > /proc/sys/net/ipv4/ip_forward

$ sudo cat /proc/sys/net/ipv4/ip_forward
1

Hacer el cambio permanente archivo /etc/sysctl.conf

# Uncomment the next line to enable packet forwarding for IPv4
net.ipv4.ip_forward=1

# sysctl -p
net.ipv4.ip_forward = 1

Install Docker Compose

# curl -L https://github.com/docker/compose/releases/download/1.8.0/\
docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose

Comprobar la instalación
# docker-compose -v
docker-compose version 1.8.0, build 94f7016

Configurar WordPress con docker-compose

WordPress está oficialmente disponible en Docker Hub, pero no va a crear un sitio web que funcione por sí mismo, requiere una base de datos para almacenar el contenido. MariaDB es un sistema de gestión de base de datos relacional creada por una comunidad de desarrolladores, un reemplazo para MySQL y disponible oficialmente en Docker.

La creación de containers con docker-compose pasa por crear dos archivos, un dockerfile y un docker-compose.yml en el directorio de trabajo.

Creando el directorio de trabajo

$ mkdir ~/wordpress-compose
$ cd ~/wordpress-compose

Al archivo Dockerfile añadimos las siguientes líneas

FROM orchardup/php5
ADD . /code

Ahora creamos el archivo docker-compose.yml, que dirá a Docker como iniciar los containers Wordpress y MariaDB.

nano docker-compose.yml

Copiar en los segmentos del ejemplo y establecer los parámetros en el archivo. Sustituya la de la base de datos e con los valores correspondientes a su servidor en la nube. Para este lab el valor en la máquina local es - 8585:80. Asegúrese de que la contraseña es la misma para ambas variables de entorno de manera que WordPress sea capaz de acceder a la base de datos. restart: always inicia los containers al iniciar el sistema (máquina local).

wordpress:
image: wordpress
links:
– mariadb:mysql
environment:
– WORDPRESS_DB_PASSWORD=password
ports:
– IP public server:80:80
volumes:
– ./code:/code
– ./html:/var/www/html
mariadb:
image: mariadb
environment:
– MYSQL_ROOT_PASSWORD=password
– MYSQL_DATABASE=wordpress
volumes:
– ./database:/var/lib/mysql

Mi archivo docker-compose.yml es:

wordpress:
   image: wordpress
   restart: always
   links:
     - mariadb:mysql
   environment:
     - WORDPRESS_DB_PASSWORD=password
   ports:
     - 8585:80
   volumes:
     - ./code:/code
     - ./html:/var/www/html
mariadb:
   image: mariadb
   restart: always
   environment:
     - MYSQL_ROOT_PASSWORD=password
     - MYSQL_DATABASE=wordpressbase
   volumes:
     - ./database:/var/lib/mysql

Ahora cree los nuevos contenedores con comando a continuación. Esto inicia ambos contenedores en segundo plano y los deja ejecuntando. Si desea ver la salida de los contenedores omita la -d para desplegar las aplicaciones en primer plano.

docker-compose up -d

A continuación, puede abrir la IP o de dominio de su servidor de WordPress en su navegador web para probar la instalación y será dirigido a la página de configuración inicial de WordPress.

Si desea realizar cambios en la configuración, sólo tiene que actualizar los archivos y ejecutar docker-compose de nuevo. Si docker-compose detecta cambios en la configuración o la imagen ha cambiado desde que el contenedor fue creado, aplica los cambios para y vuelve a crear los containers preservando al mismo tiempo los volúmenes montados. Genial.

Por ejemplo, puede comprobar si hay actualizaciones en las imágenes de WordPress y
 MariaDB y aplicar cambios en los containers utilizando los comandos:

docker-compose pull
docker-compose up -d

Listando el directorio de trabajo:

Otros comandos docker-compose:

# Iniciar todos los containers detenidos en el directorio de trabajo
$ docker-compose start

# Parar todos los containers en ejecución en el directorio de trabajo
$ docker-compose stop

# Valida y muestra la configuración
$ docker-compose config

# Lista todos los containers en ejecución en el directorio de trabajo
$ docker-compose ps

# Detiene y elimina todos los containers en el directorio de trabajo
$ docker-compose down

$ docker-compose logs

docker-compose crea containers a la vez que simplifica la gestión de aplicaciones, docker-compose va un paso más allá y te permite agrupar varios contenedores dentro de un directorio de trabajo individual.

carles@note:~$ docker ps
CONTAINER ID  IMAGE     COMMAND                  CREATED STATUS              PORTS                  NAMES
6330c10fbaf7  wordpress “/entrypoint.sh apach”   About   About     0.0.0.0:8585->80/tcp  wordpresscompose_wordpress_1
1e3fe89acca1  mariadb    “docker-entrypoint.sh”   About an hour   Up About   3306/tcp       wordpresscompose_mariadb_1

Antes de continuar con la construcción de su nuevo sitio WordPress, asegúrese de prestar atención a la seguridad en su cloud server. En este sentido vamos a implementar Iptables firewall con política de deny por defecto.

Para empezar, tendrá que instalar el paquete iptables-persistent si no lo ha hecho ya. Esto nos permitirá guardar el conjunto de reglas que sera aplicado de forma automática en el arranque:

Instalar el servicio Persistent Firewall

$ sudo apt-get update
$ sudo apt-get install iptables-persistent

Durante la instalación, se le preguntará si desea guardar sus reglas actuales, conteste sí.

Primero renombre el archivo actual:

# mv /etc/iptables/rules.v4 /etc/iptables/rules.v4-bak

Este es el nuevo contenido del archivo /etc/iptables/rules.v4:

# vi /etc/iptables/rules.v4

######################################################################
*filter
# Allow all outgoing, but drop incoming and forwarding packets by default
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]

# Custom per-protocol chains
:UDP - [0:0]
:TCP - [0:0]
:ICMP - [0:0]

# Acceptable UDP traffic

# Docker rules copiadas de rules.v4
:DOCKER - [0:0]
:DOCKER-ISOLATION - [0:0]
-A FORWARD -j DOCKER-ISOLATION
-A FORWARD -o docker0 -j DOCKER
-A FORWARD -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i docker0 ! -o docker0 -j ACCEPT
-A FORWARD -i docker0 -o docker0 -j ACCEPT
-A DOCKER-ISOLATION -j RETURN
# Acceptable TCP traffic
-A TCP -p tcp --dport 22 -j ACCEPT

# Acceptable ICMP traffic

# Boilerplate acceptance policy
-A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
-A INPUT -i lo -j ACCEPT

# Drop invalid packets
-A INPUT -m conntrack --ctstate INVALID -j DROP

# Pass traffic to protocol-specific chains
## Only allow new connections (established and related should already be handled)
## For TCP, additionally only allow new SYN packets since that is the only valid
## method for establishing a new TCP connection
-A INPUT -p udp -m conntrack --ctstate NEW -j UDP
-A INPUT -p tcp --syn -m conntrack --ctstate NEW -j TCP
-A INPUT -p icmp -m conntrack --ctstate NEW -j ICMP

# Reject anything that's fallen through to this point
## Try to be protocol-specific w/ rejection message
-A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
-A INPUT -p tcp -j REJECT --reject-with tcp-reset
-A INPUT -j REJECT --reject-with icmp-proto-unreachable

# Commit the changes
COMMIT

*raw
:PREROUTING ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
COMMIT

*nat
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
:DOCKER - [0:0]
-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER
-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
-A DOCKER -i docker0 -j RETURN
COMMIT

*security
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
COMMIT

*mangle
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
COMMIT
###################################################################

Guarde y cierre el archivo
Puede probar el archivo de errores de sintaxis escribiendo este comando.:
# iptables-restore -t /etc/iptables/rules.v4

Si no hay errores de sintaxis, puede aplicar las reglas escribiendo:
# service iptables-persistent reload

Listar todas las reglas e imprimor las direcciones IP y números de puerto en formato numérico.

$ sudo iptables -L -n
Chain INPUT (policy DROP)
target     prot opt source               destination         
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0            ctstate RELATED,ESTABLISHED
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           
DROP       all  --  0.0.0.0/0            0.0.0.0/0            ctstate INVALID
UDP        udp  --  0.0.0.0/0            0.0.0.0/0            ctstate NEW
TCP        tcp  --  0.0.0.0/0            0.0.0.0/0            tcp flags:0x17/0x02 ctstate NEW
ICMP       icmp --  0.0.0.0/0            0.0.0.0/0            ctstate NEW
REJECT     udp  --  0.0.0.0/0            0.0.0.0/0            reject-with icmp-port-unreachable
REJECT     tcp  --  0.0.0.0/0            0.0.0.0/0            reject-with tcp-reset
REJECT     all  --  0.0.0.0/0            0.0.0.0/0            reject-with icmp-proto-unreachable

Chain FORWARD (policy DROP)
target     prot opt source               destination         
DOCKER-ISOLATION  all  --  0.0.0.0/0            0.0.0.0/0           
DOCKER     all  --  0.0.0.0/0            0.0.0.0/0           
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0            ctstate RELATED,ESTABLISHED
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination         

Chain DOCKER (1 references)
target     prot opt source               destination         
ACCEPT     tcp  --  0.0.0.0/0            172.17.0.3           tcp dpt:80

Chain DOCKER-ISOLATION (1 references)
target     prot opt source               destination         
RETURN     all  --  0.0.0.0/0            0.0.0.0/0           

Chain ICMP (1 references)
target     prot opt source               destination         

Chain TCP (1 references)
target     prot opt source               destination         
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0            tcp dpt:22

Chain UDP (1 references)
target     prot opt source               destination

Imprimir todas las cadenas como iptables-save

$ sudo iptables -S
-P INPUT DROP
-P FORWARD DROP
-P OUTPUT ACCEPT
-N DOCKER
-N DOCKER-ISOLATION
-N ICMP
-N TCP
-N UDP
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -m conntrack --ctstate INVALID -j DROP
-A INPUT -p udp -m conntrack --ctstate NEW -j UDP
-A INPUT -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -m conntrack --ctstate NEW -j TCP
-A INPUT -p icmp -m conntrack --ctstate NEW -j ICMP
-A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable
-A INPUT -p tcp -j REJECT --reject-with tcp-reset
-A INPUT -j REJECT --reject-with icmp-proto-unreachable
-A FORWARD -j DOCKER-ISOLATION
-A FORWARD -o docker0 -j DOCKER
-A FORWARD -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -i docker0 ! -o docker0 -j ACCEPT
-A FORWARD -i docker0 -o docker0 -j ACCEPT
-A DOCKER -d 172.17.0.3/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 80 -j ACCEPT
-A DOCKER-ISOLATION -j RETURN
-A TCP -p tcp -m tcp --dport 22 -j ACCEPT

Bibliografía:
- https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-and-phpmyadmin-with-docker-compose-on-ubuntu-14-04
- https://docs.docker.com/
- https://github.com/nazar-pc/docker-webserver

Unix es genial!

CIFS Cliente FreeBSD

smbutil SMB CIFS Cliente FreeBSD

Samba4 ipfw

Las redes mixtas están aquí y han llegado para quedarse. FreeBSD (BSD Unix) proporciona los programas smbutil Y mount_smbfs para conectar a los recursos compartidos SMB/CIFS. Ninguno de los programas es parte de Samba. El programa smbutil proporciona una funcionalidad similar a algunas de las utilidades de línea de comandos de la suite Samba. Se puede utilizar para enumerar las acciones disponibles en un servidor SMB o realizar búsquedas de nombres de NetBIOS.

FreeBSD incluye el Programa smbutil para encontrar, montar y utilizar recursos compartidos CIFS.

Utilizaremos el soporte CIFS de FreeBSD para interoperar con la infraestructura existente de un servidor Samba configurado con anterioridad.

Debe obtener un nombre de usuario y contraseña válido con acceso al recurso compartido, capacidad de encontrar el servidor Samba (servidor de archivos) mediante el nombre de host o su dirección IP.

En el lado del cliente FreeBSD es necesario cargar el módulo del kernel smbfs.ko que a su vez proporciona los módulos libiconv.ko y libmchain.ko.

Para habilitar en tiempo de arranque añadiremos la siguiente entrada al fichero /boot/loader.conf

smbfs_load="YES"

Cargar el módulo
# kldload smbfs

Estado de los módulos del kernel activos
# kldstat

Fichero de configuración

El archivo de configuración /etc/nsmb.conf se divide en secciones. Cada sección comienza con una etiqueta entre corchetes. Los ajustes que se aplican a todas las conexiones CIFS están en la sección [default]. También crearemos otra etiqueta que proporciona valores como nombre de host del servidor, nombre de usuario y contraseña, encriptada a través de crypt “hash de una pasada” (sólo pueden ser fácilmente cifradas pero no descifradas).

# smbutil crypt pAssw@rdUs3r#r
$$17866542346c0b13f2d8fb9fd5c71

Fichero de configuración /etc/nsmb.conf

Cada sección puede contener cero o más parámetros

[section_name]
key=value

Donde key representa el nombre del parámetro y value el valor asignado a este parámetro

La librería SMB usa el siguiente formato de nombres de seccíon. (El nombre de la sección aparece en mayúscula cuando se refiere al servidor, usuario o recurso compartido).
[default]
[SERVER]
[SERVER:USER]
[SERVER:USER:SHARE]

nbns NetBios servidor de nombre
addr Dirección IP del servidor

[default]
workgroup=MYOFFICE
addr= 192.168.1.110
nbns=192.168.1.110
charsets=cp852

[FBSDSMB:LUCA:LUCA]
password=$$17866542346c0b13f2d8fb9fd3

Que recursos comporte el servidor?
# smbutil view //username@IPSERVER
Password:

Montar el recurso compartido del usuario luca

# mount_smbfs //luca@192.168.1.110/luca /usr/home/carles/shareluca
# ls /home/carles/shareluca

Lo que tenemos montado en nuestro cliente FreeBSD:

# Mount

Si no queremos hacer visible los archivos ocultos del usuario luca añadimos al archivo de configuración del servidor Samba la siguiente entrada.

[luca]
...
veto files = /.*
...

Si esta línea la agregamos a la sección default del fichero de configuración de Samba, se aplicará a todos los recursos compartidos.

[default]
...
veto files = /.*
...

FreeBSD es genial!.

Samba 4 ipfw en FreeBSD 10.3

Configurar Samba4 e ipfw firewall

Nivel: Avanzado

$ cat /boot/loader.conf
...
autoboot_delay="2"
loader_logo="beastie"
sem_load=YES
mqueuefs_load=YES

Samba es una implementación libre del protocolo de archivos compartidos de Windows (SMB y CIFS) para sistemas de tipo UNIX. De manera que nuestro pc con FreeBSD se vea como servidor de archivos en redes Windows.

Dirección IP del servidor Samba

$ cat /etc/rc.conf | grep ifconfig_em0
ifconfig_em0="inet 192.168.1.110 netmask 255.255.255.0"

# hostname
root@fbsdsmb

Instalar samba42
# pkg search samba
# pkg install samba42

Un solo usuario accediendo a su directorio personal

La forma más fácil de configurar un cliente es crear una cuenta Unix y su correspondiente directorio personal para el cliente en el servidor, luego  notificar a Samba la existencia de ese usuario. Posteriormente en el fichero de configuración de Samba se creará un recurso de disco compartido que apunte al directorio personal del usuario y a traves de valid users restringiremos su acceso.

# adduser
...

# smbpasswd -a luca

[luca]
path = /home/luca
comment = Luca's Home Directory
writeable = yes
valid users = luca

o puedes referirte al directorio personal del usuario usando la variable %H. También puedes utilizar las variables de nombre de usuario Unix %u y de nombre de usuario cliente %U.

[luca]
comment = %U Home Directory
writeable = yes
valid users = luca
path = %H

Estos dos ejemplos funcionan mientras el usuario Unix que Samba utiliza para referirse al cliente tiene derechos de lectura/escritura sobre el directorio al que se refiere la opcion path.

Agregar usuario luca a Samba
# smbpasswd -a luca

Acceso de grupo a un recurso compartido

Si estás creando un directorio compartido para acceso de grupo, hay varios pasos adicionales a realizar. Vamos a echar un vistazo a un recurso compartido para el departamento de Contabilidad en el fichero smb4.conf:

[contabilidad]
comment = Directorio Departmento de Contabilidad
writeable = yes
valid users = @cuenta
path = /srv/accounting
create mode = 0660
directory mode = 0770

@account como el usuario válido en lugar de uno o más nombres de usuario individuales es un atajo para decir que los usuarios válidos están  representados por el grupo Unix cuenta. Estos usuarios necesitan ser añadidos al grupo cuenta en el fichero de grupos del sistema (/etc/group) para ser reconocidos como parte del grupo. Una vez que lo son, Samba los reconocerá como usuarios válidos para el recurso compartido. Necesitarás crear un directorio compartido para que los miembros del grupo tengan acceso, que será mapeado a través de la opción de configuración path.


# mkdir /srv/accounting
# chgrp cuenta /srv/accounting
# chmod 770 /srv/accounting

Crear grupo cuenta
# pw groupadd cuenta

Agregar usuario luca al grupo cuenta
# pw groupmod cuenta -M luca

Ejemplos de usuarios, grupos y comparticiones

Crear los directorios
# mkdir -p /svr/p
# mkdir /svr/s
# mkdir /svr/t
# mkdir /srv/public

Añadir los usuarios al sistema FreeBSD
# adduser
Username: prof
...
# adduser
Username: super
...
# adduser
Username: argo
...
# adduser
Username: invitado
...
# adduser
Username: susiaxel

Establecer los usuarios propietarios de los directorios

# chown -R prof:prof /svr/p
# chown -R super:super /svr/s
# chown -R argo:prof /svr/t
# chown -R invitado:invitado /svr/public

Crear nuevos grupos

# pw groupadd stp
# pw groupadd tp

Agregar usuario super al grupo stp

# pw groupmod stp -M super

Agregar usuarios argo y prof al grupo tp

# pw groupmod tp -M argo,prof

Agregar usuarios invitado y susiaxel al grupo invitado

# pw groupmod invitado -M invitado,susiaxel
# pw groupshow tp
tp:*1009:prof,argo
# pw groupshow invitado
invitado:*:1007:invitado,susiaxel

Archivo de configuración de Samba /usr/local/etc/smb4.conf

##############INICIO###############
[global]

invalid users = root bin daemon adm sync shutdown \
halt mail news uucp operator gopher
workgroup = MYOFFICE
server string = My Office Server
dos charset = cp850
unix charset = UTF-8
fstype = NTFS
security = user
encrypt passwords = yes
wins support = yes
name resolve order = wins lmhosts hosts bcast
max open files = 16384
use mmap = yes
unix extensions = no
hosts allow = 192.168.1. 192.168.3. localhost

# Debug logging information
log level = 2
log file = /var/log/samba4/samba.log.%m
max log file = 100
debug timestamp = yes

# Browsing election options
os level = 34
local master = yes

[homes]

comment = Home Directories
browseable = no
writeable = yes
directory mask = 0750
create mask = 0644

[luca]

comment = %U Home Directory
writeable = yes
valid users = luca path = %H

[contabilidad]

comment = Directorio Departmento de Contabilidad
writeable = yes
valid users = @cuenta
path = /srv/accounting
create mode = 0660
directory mode = 0770

[public]

comment = public
path = /srv/public
public = no
writeable = yes
write list = @invitado
directory mask = 0770
create mask = 0660

[super]

comment = super
path = /srv/s
public = no
writeable = yes
write list = super
directory mask = 0750
create mask = 0644

[profesores]

comment = Profesores
path = /srv/p
public = no
writeable = yes
write list = prof, @stp
directory mask = 0750
create mask = 0644

[alumnos]

comment = alumnos
path = /srv/t
public = no
writeable = yes
write list = super, @tp
directory mask = 0770
create mask = 0660
#############FINAL###############

Habilitar Samba server

# echo 'samba_server_enable="YES"'>>/etc/rc.conf

Iniciar el servicio
# service samba_server start

Opciones de ficheros de registro

Hemos añadido un fichero de registro de usuario que reporta información de depuración de nivel 2. El nivel 2 nos proporcionará información útil sin ocupar mucho espacio en disco en el sevidor.

Este fichero está localizado en el directorio /var/log/samba4 definido con la opción log file del fichero de configuración. Podemos usar una de las variables proporcionada por Samba para crear ficheros de registro independientes para cada cliente, como la variable %m.
log file = /var/log/samba4/samba.log.%m

Aislar los mensajes de registro puede resultar útil en el momento de tener que rastrear un error de red si el problema viene de una máquina o cliente determinado. Ninguno de ellos puede exceder en tamaño de 100 kb, indicado en la opción log size.

La fecha y la hora de la depuración en los registros nos la proporciona la opción debug timestamp, el cual es el valor por defecto. Coloca una cadena de fecha y hora en el formato timestamp junto a cada mensaje en el fichero de registro.

Recurso compartido homes

La sección [homes] puede representar cualquier cuenta en la máquina, esto no es deseable. Por ejemplo, podría crear un recurso compartido para root, bin, uucp y similares. La opción invalid users protege frente a esto.

Si un usuario intenta conectar a un recurso compartido ordinario que no aparece en el fichero smb.conf, Samba va a buscar el recurso compartido [homes]. Si no existe, el nombre del recurso compartido enviado a Samba se asume como un nombre de usuario y se busca como tal su contraseña en la base de datos (/etc/passwd) del servidor Samba. Si aparece, Samba asume que el cliente es un usuario Unix intentando conectar a su directorio personal.

Si susi esta intentando conectar a un recurso compartido llamado [susi] en el servidor Samba. Existe un recurso compartido [homes], No hay un recurso compartido con ese nombre en el fichero de configuración, el usuario susi está presente en la base de datos de contraseñas entonces, Samba crea un nuevo recurso compartido llamado [susi] con el  especificado en la seccion, Samba la inicializa a su directorio personal. Samba inicializa las opciones del nuevo recurso a partir de las opciones por defecto de la sección [globals], por último conecta al cliente susi a este nuevo recurso.

Aumentar la seguridad

Hemos visto que ocurre cuando especificas usuarios válidos, también puedes establecer una lista de usuarios no válidos, a los que nunca les será permitido acceder a Samba o a sus recursos. Esto se hace con la opción invalid users. Un valor por defecto relacionado con la sección [homes] para asegurar que determinados usuarios y superusuarios del sistema no pueden ser manipulados o alterados para conseguir acceso a éste.

[global]

invalid users = root bin daemon adm sync shutdown \
halt mail news uucp operator gopher

Por conveniencia, decidimos habilitar la opción del fichero Samba hosts allow = 192.168.1. 192.168.3. localhost que permite conectar con nuestro servidor desde las redes: 192.168.3.0/25 y 192.168.1.0/24. Una vez hecho esto cambiaremos la dirección IP del servidor a la dirección 192.168.3.110 para que quede detrás de nuestro firewall basado en openbsd, soekris y pf, configurado en un artículo anterior cuya IP es 192.168.3.1 y con DHCP activado.

Cambiar IP y puerta de enlace del servidor:

# ee /etc/rc.conf
ifconfig_em0="inet 192.168.3.110 netmask 255.255.255.128"
defaultrouter="192.168.3.1"
...

Cambios en el Firewall ipfw

A continuación añadimos estas dos líneas al fichero de configuración del firewall /etc/ipfw.rules

add 5139 allow tcp from 192.168.3.0/25 to any 139 keep-state setup
add 5300 allow ip from 192.168.3.0/25 to 192.168.3.0/25

Conexiones físicas

Conectamos los cables ethernet al router Soekris de las máquinas involucradas. En este caso nuestro servidor, la máquina win xp, la máquina win 7, cualquier otra máquina conectadas directamente al router cuya ip es 192.168.1.1 (proveedor ISP) también podrá acceder a los recursos del servidor como ya hemos visto.

# service samba_server restart
# service ipfw restart

El servidor Samba está actuando como visualizador maestro local para la actual subred

nmbd/nmbd_become_lmb.c:become_local_master_stage2

*****

Samba name server FBSDSMB is now a local master browser for

workgroup MYOFFICE on subnet 192.168.3.110

****

write list - Una lista de usuarios o grupos (nombres de grupo tienen el prefijo @) que será capaz de escribir a este recurso compartido. Los permisos de usuarios adecuados todavía tienen que ser establecidos en el directorio.

directory mask - por defecto - 0755
create mask - por defecto - 0744
force create mode - por defecto - 000
force directory mode - por defecto - 0000

En Samba en lugar de definir lo que está restringido, define lo que está permitido.

Los siguientes valores de las opciones definidas de un recurso compartido en smb4.conf :

directory mask = 0700
create mask = 0600

directory mask. Permite al usuario propietario permisos de lectura, escritura y ejecución. Al grupo y otros no les permite ni leer, ni escribir, ni ejecutar (no tendrán acceso a este directorio).

create mask. Permisos de lectura, escritura al usuario propietario. El grupo y otros no tienen permisos de lectura ni escritura.

create mask = 744

Por ejemplo, la opción create mask forzará que los permisos de un archivo creado por un cliente Windows sean, como mucho, 744

mientras que la opción directory mask que mostramos a continuación forzará los permisos de un recién creado directorio a, como mucho, 755:

directory mask = 755

directory mask - Recomendamos la máscara 0750 o rwxr−x−−−, eliminando la posibilidad de acceso al resto de usuarios que no son tú, y no pertenecen a tu grupo. 

create mask - Si necesitas cambiarlo a archivos no ejecutables, recomendamos 0644, o rw−r−r−.

Como ejemplo, considere los siguientes valores de las opciones definidas de un recurso compartido en smb4.conf :

create mask = 0770
directory mask = 0770

Esto permitiría ambos, archivos y directorios leer, escribir y ejecutar permisos para usuario y grupo, pero no a otros. Al mismo tiempo, obliga al grupo permisos leer y escribir para archivos y de lectura, escritura y ejecución para los directorios.

testparm comprueba la existencia de errores en el fichero de configuración del servidor Samba

# testparm

Solucionar errores 

# sysctl kern.maxfilesperproc=16384
kern.maxfilesperproc: 14040 -> 16384
# sysctl kern.maxfiles=16384
kern.maxfiles: 14040 -> 16384

Hacer permanente los cambios

# echo 'kern.maxfilesperproc=16384'>>/etc/sysctl.conf
# echo 'kern.maxfiles=16384'>>/etc/sysctl.conf

Que está ofreciendo el servidor a la red

# smbclient -U% -L localhost

Sincronizar usuarios

Esto se puede resolver de tres maneras: en primer lugar al mantener manualmente los usuarios de FreeBSD y sincronizar con una base de datos de usuario Samba - específica mediante la utilidad smbpasswd. Esta utilidad se comporta de manera similar a la utilidad "pw". Es la solución más simple y se recomienda para pequeñas instalaciones con varios usuarios, que muy rara vez cambian sus contraseñas. Tenga en cuenta que primero tendrá que añadir un usuario a FreeBSD (shell-nologin), y luego añadir un usuario Samba con el mismo nombre usando "smbpasswd -a".

Despúes de añadir usuarios a FreeBSD lo agregamos a Samba 

# smbpasswd -a super
# smbpasswd -a prof
# smbpasswd -a argo
# smbpasswd -a invitado
# smbpasswd -a susiaxel


Implementación del firewall ipfw

Los firewalls de red bloquean (previenen) a ciertos tipos de paquetes de red llegar a determinados servicios del sistema. la práctica moderna de seguridad es en realidad para bloquear todos los paquetes excepto un pequeño conjunto de elegidos, con el fin de reducir al mínimo la superficie de ataque, o el número y el alcance de los servicios que están expuestos a la red.

En este caso permitimos todo tráfico IP mediante la interfaz loopback, ssh, http, https, samba-cifs, permitir todos los paquetes IP independientemente del protocolo o cualquier otro detalle de todas las direcciones en una red local a todas las direcciones en la misma red, Niega todos los demás paquetes de red y los registra en syslog.

# cat /etc/ipfw.rules

###########INICIO####################
add 500 allow ip from any to any via lo0

add 1000 allow icmp from any to any

add 2000 allow tcp from me to any setup keep-state

add 2001 allow udp from me to any keep-state

add 4022 allow tcp from any to me 22 setup keep-state

add 4080 allow tcp from any to me 80, 443 setup keep-state

add 4139 allow tcp from 192.168.1.0/24 to any 139 keep-state setup

add 5000 allow ip from 192.168.1.0/24 to 192.168.1.0/24

add 5139 allow tcp from 192.168.3.0/25 to any 139 keep-state setup

add 5300 allow ip from 192.168.3.0/25 to 192.168.3.0/25

add 65400 deny log ip from any to any
###############FINAL#####################

# echo 'firewall_enable="YES"'>>/etc/rc.conf
# echo 'firewall_type="/etc/ipfw.rules"'>>/etc/rc.conf

# service samba_server restart
# service ipfw restart

# netstat -a | grep ipv4
# ipfw list

Eleccion de Visualizador

Samba puede usar una elección de visualizador para una variedad de resultados, incluyendo el ser siempre el visualizador maestro local de la subred o no serlo nunca. Por ejemplo, las siguientes opciones (sección global), asegurará que Samba siempre gane la elección de visualizador maestro local, sin importar qué otras máquinas estén presentes en la red:

# Browsing election options

os level = 34

local master = yes

Saber si una máquinan es el visualizador maestro local

Usando el comando nbtstat puedes saber si una máquina es el visualizador maestro local. Coloca el nombre NetBIOS de la máquina que quieras interrogar tras la opción −a:

C:\> nbtstat -a fbsdsmb

La línea que estás buscando es ..__MSBROWSE__.<01>. Indica que el servidor está actuando como el visualizador maestro local para la actual subred. 

Conectar con un recurso compartido desde un ordenador con Windows XP. 

En este caso utilizando el nombre del servidor y el nombre del recurso compartido (alumnos), que pertenece al usuario argo. El nombre de usuario y la contraseña que fueron creadas en el cliente deben coincidir con la combinación usuario/contraseña del servidor.

Desde un ordenador con Windows 7 conectamos con un recurso compartido. Los usuarios solo podrán acceder a los archivos y carpetas cuyos permisos sean establecidos en el archivo smb4.conf.

Referencias:
https://wiki.freebsd.org/Samba
https://www.freebsd.org/doc/faq/
http://es.tldp.org/Manuales-LuCAS/USANDO-SAMBA/usando-samba.pdf

Unix es genial!.