Páginas

Buscar este blog

domingo, 23 de octubre de 2016

Slackware 14.2 KDE

Instalar Slackware 14.2 y actualizar kde 4.14.3 a kde 5 plasma 64 bit uefi
Hardware : procesador Intel Braswell, 8 gb de ram, disco duro ssd 120 GB

Slackware Live Edition

El programa setup2hd, incluido en el live dvd, es un instalador de Slackware modificado que le guiará a través de los conocidos menús de configuración e instalará el contenido de Slackware Live Edition en su disco duro. Se puede ejecutar desde su sesión X y seguir interactuando con Internet mientras se instala Slackware.

Compatibilidad con System V

Compatibilidad del sistema V init se introdujo en Slackware 7.0. Muchas otras distribuciones de Linux hacen uso de este estilo en vez del estilo BSD. Básicamente cada nivel de ejecución se da un subdirectorio para los scripts de init, mientras que el estilo BSD brinda un script de inicio para cada nivel de ejecución.

El script rc.sysvinit buscará cualquier scripts de inicio System V que tenga en /etc/rc.d y utilizarlos, si es adecuado el nivel de ejecución.

Al ejecutar del slackdvd de instalación  lo primero es elegir el teclado querty/es.map (español España).

Particionado con cfdisk
Justo después de crear las particiones con cfdisk es importante asegurarse que la partición sda1 tiene el formato correcto. No es suficiente con solo indicar que el type es Efi System.
# mkfs.vfat /dev/sda1



Una vez creadas las particiones el resto del proceso es muy intuitivo y no explico porque no contempla dificultad alguna.

Continua la instalación  tecleando desde la linea de comando
# setup

El resto de la instalación es muy intuitivo. Al final elegimos las opciones por defecto para el escritorio kde e incluimos kdei que el paquete de idiomas de kde.

locales

/etc/profile.d/lang.sh

Ver idiomas disponibles
# locale -a

No copie la salida literal de locale -a, no tendrá soporte unicode.

Lenguaje es España lang.sh

# nano -w /etc/profile.d/lang.sh
export LANG="es_ES.UTF-8"
export LC_MESSAGES="es_ES.UTF-8"
export LC_CTYPE="es_ES@euro"
export LC_COLLATE="es_ES@euro"
export LC_TIME="es_ES.UTF-8"
export LC_NUMERIC="es_ES.UTF-8"
export LC_MONETARY="es_ES@euro"
export LC_PAPER="es_ES.UTF-8"
export LC_TELEPHONE="es_ES.UTF-8"
export LC_ADDRESS="es_ES.UTF-8"
export LC_MEASUREMENT="es_ES.UTF-8"
export LC_NAME="es_ES.UTF-8"


Existen buenas razones por las que Slackware no activa unicode por defecto:
# unicode_stop
# unicode_start

Ver actual fuente de consola
# showconsolefont

Ubicación de las fuentes:
# ls /usr/share/kbd/consolefonts.

Para elegir una fuente de consola tecleamos en la terminal: 
# setconsolefont

Alternativamente puede utilizar el archivo rc.font
# cat -w /etc/rc.d/rc.font
#!/bin/sh
setfont -v lat9-16.psf.gz

Slackpkg
Es una herramienta para instalar o actualizar paquetes a través de una red,  desde un espejo de Slackware.
 
Instalar Slackpkg desde el SlackDVD
# cd /mnt/cdrom/slackware64/np/
# installpkg slackpkg-2.82.1-noarch-3.txz

Abrir el archivo mirrors y utilizar el mas cercano, descomentando la linea correspondiente, p.e
# PORTUGAL (PT)
http://darkstar.ist.utl.pt/pub/slackware/slackware64-14.2/

# nano /etc/slackpkg/mirrors

# slapkpg update gpg
# slackpkg update

Archivo de configuracion slackpkg

# sed -e '/^[ ]*#/d' -e '/^$/d' /etc/slackpkg/slackpkg.conf
TEMP=/sda6/var/cache/packages
WORKDIR=/var/lib/slackpkg
WGETFLAGS="--passive-ftp"
DELALL=on
CHECKMD5=on
CHECKGPG=on
CHECKSIZE=on
PRIORITY=( patches %PKGMAIN extra pasture testing )
POSTINST=on
ONLY_NEW_DOTNEW=off
ONOFF=on
DOWNLOAD_ALL=off
DIALOG=on
BATCH=off
DEFAULT_ANSWER=n
USE_INCLUDES=on
SPINNING=on
DIALOG_MAXARGS=139000

Archivo blacklist. Incluye los paquetes que no deben ser actualizados.

#/d' -e '/^$/d' /etc/slackpkg/blacklist    
#xorg-server
#kernel-firmware
#kernel-generic
#kernel-generic-smp
#kernel-headers
#kernel-huge
#kernel-huge-smp
#kernel-modules
#kernel-modules-smp
#kernel-source

Instalar slackpkg+ Descargar desde 
https://sourceforge.net/projects/slackpkgplus/ 
$ cd Download/
# installpkg slackpkg+-1.7.0-noarch-4mt.txz

Ejemplo del archivo de configuracion slackpkgg+

# sed -e '/^[ ]*#/d' -e '/^$/d' /etc/slackpkg/slackpkgplus.conf
SLACKPKGPLUS=on
VERBOSE=1
ALLOW32BIT=off
USEBL=1
WGETOPTS="--timeout=20 --tries=2"
SEARCH_CLOG_INPARENT=on
CACHEUPDATE=off
GREYLIST=on
SENSITIVE_SEARCH=on
WW_FILE_SEARCH=on
SHOWORDER=package
DETAILED_INFO=none
STRICTGPG=on
PKGS_PRIORITY=( ktown )
TAG_PRIORITY=off
REPOPLUS=( slackpkgplus alien alien_restricted )
MIRRORPLUS['slackpkgplus']=http://slakfinder.org/slackpkg+/
MIRRORPLUS['alien']=http://bear.alienbase.nl/mirrors/people/alien/sbrepos/14.2/x86_64/
MIRRORPLUS['alien_restricted']=http://bear.alienbase.nl/mirrors/people/alien/restricted_sbrepos/14.2/x86_64/
MIRRORPLUS['slackpkgplus']=http://slakfinder.org/slackpkg+/
MIRRORPLUS['ktown']=http://alien.slackbook.org/ktown/14.2/5/x86_64/

El sistema verifica la firma GPG de cada paquete (por defecto), slackpkg.conf
CHECKGPG=on

Como se utiliza el manejador de paquetes slackpkg?
bash-4.3# slackpkg help

slackpkg - version 2.81 / slackpkg+ 1.7.0

Usage:  slackpkg update [gpg]           download and update files and 
                                        package indexes
        slackpkg check-updates          check if there is any news on
                                        Slackware's ChangeLog.txt
        slackpkg install package        download and install packages 
        slackpkg upgrade package        download and upgrade packages
        slackpkg reinstall package      same as install, but for packages 
                                        already installed
        slackpkg remove package         remove installed packages
        slackpkg clean-system           remove all packages which are not 
                                        present in the official Slackware 
                                        package set. Good to keep the house
                                        in order
        slackpkg upgrade-all            sync all packages installed in your 
                                        machine with the selected mirror. This
                                        is the correct way to upgrade all of 
                                        your machine.
        slackpkg install-new            install packages which are added to
                                        the official Slackware package set.
                                        Run this if you are upgrading to another
                                        Slackware version or using current.
        slackpkg blacklist              Blacklist a package. Blacklisted
                                        packages cannot be upgraded, installed,
                                        or reinstalled by slackpkg
        slackpkg download               Only download (do not install) a package
        slackpkg info package           Show package information 
                                        (works with only ONE package)
        slackpkg search package         Search packages that have a
                                        selected name
        slackpkg file-search file       Search for a specific file in the
                                        entire package collection
        slackpkg new-config             Search for new configuration files and
                                        ask to user what to do with them.
        slackpkg generate-template      Create a template with all 
                                        official Slackware packages installed 
                                        in your machine.
        slackpkg install-template       Install selected template.
        slackpkg remove-template        Remove selected template. Be careful.
        slackpkg help                   Show this screen. 


Antes de utilizar slackpkg ejecutamos:
# slackpkg update gpg
# slackpkg update && slackpkg update

instalar iptables y nmap desde SlackDVD
# cd /run/media/carles/SlackDVD/slackware64/n

# installpkg iptables-1.6.0-x86_64-2.txz

# installpkg nmap-7.12-x86_64-1.txz

Generar reglas de Firewall fácil. Adaptado para Slackware.
Archivo de configuración de iptables /etc/rc.d/rc.firewall chmod +x /etc/rc.d/rc.firewall (ejecutable)
############################################
SYSCTL="/sbin/sysctl -w" 
IPT="/usr/sbin/iptables"
IPTS="/usr/sbin/iptables-save"
IPTR="/usr/sbin/iptables-restore"
INET_IFACE="eth0"
LO_IFACE="lo"
LO_IP="127.0.0.1"
if [ "$1" = "save" ]
then
 echo -n "Saving firewall to /etc/sysconfig/iptables ... "
 $IPTS > /etc/sysconfig/iptables
 echo "done"
 exit 0
elif [ "$1" = "restore" ]
then
 echo -n "Restoring firewall from /etc/sysconfig/iptables ... "
 $IPTR < /etc/sysconfig/iptables
 echo "done"
 exit 0
fi
echo "Loading kernel modules ..."
/sbin/modprobe ip_tables
/sbin/modprobe ip_conntrack
/sbin/modprobe ip_nat_ftp
/sbin/modprobe ip_conntrack_ftp
/sbin/modprobe ip_conntrack_irc
if [ "$SYSCTL" = "" ]
then
    echo "1" > /proc/sys/net/ipv4/tcp_syncookies
else
    $SYSCTL net.ipv4.tcp_syncookies="1"
fi
if [ "$SYSCTL" = "" ]
then
    echo "1" > /proc/sys/net/ipv4/conf/all/rp_filter
else
    $SYSCTL net.ipv4.conf.all.rp_filter="1"
fi
if [ "$SYSCTL" = "" ]
then
    echo "1" > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts
else
    $SYSCTL net.ipv4.icmp_echo_ignore_broadcasts="1"
fi
if [ "$SYSCTL" = "" ]
then
    echo "0" > /proc/sys/net/ipv4/conf/all/accept_source_route
else
    $SYSCTL net.ipv4.conf.all.accept_source_route="0"
fi
if [ "$SYSCTL" = "" ]
then
    echo "1" > /proc/sys/net/ipv4/conf/all/secure_redirects
else
    $SYSCTL net.ipv4.conf.all.secure_redirects="1"
fi
if [ "$SYSCTL" = "" ]
then
    echo "1" > /proc/sys/net/ipv4/conf/all/log_martians
else
    $SYSCTL net.ipv4.conf.all.log_martians="1"
fi
echo "Flushing Tables ..."
$IPT -P INPUT ACCEPT
$IPT -P FORWARD ACCEPT
$IPT -P OUTPUT ACCEPT
$IPT -t nat -P PREROUTING ACCEPT
$IPT -t nat -P POSTROUTING ACCEPT
$IPT -t nat -P OUTPUT ACCEPT
$IPT -t mangle -P PREROUTING ACCEPT
$IPT -t mangle -P OUTPUT ACCEPT
$IPT -F
$IPT -t nat -F
$IPT -t mangle -F
$IPT -X
$IPT -t nat -X
$IPT -t mangle -X
if [ "$1" = "stop" ]
then
 echo "Firewall completely flushed!  Now running with no firewall."
 exit 0
fi
$IPT -P INPUT DROP
$IPT -P OUTPUT DROP
$IPT -P FORWARD DROP
echo "Create and populate custom rule chains ..."
$IPT -N bad_packets
$IPT -N bad_tcp_packets
$IPT -N icmp_packets
$IPT -N udp_inbound
$IPT -N udp_outbound
$IPT -N tcp_inbound
$IPT -N tcp_outbound
$IPT -A bad_packets -p ALL -m conntrack --ctstate INVALID -j LOG \
    --log-prefix "Invalid packet: "
$IPT -A bad_packets -p ALL -m conntrack --ctstate INVALID -j DROP
$IPT -A bad_packets -p tcp -j bad_tcp_packets
$IPT -A bad_packets -p ALL -j RETURN
$IPT -A bad_tcp_packets -p tcp ! --syn -m conntrack --ctstate NEW -j LOG \
    --log-prefix "New not syn: "
$IPT -A bad_tcp_packets -p tcp ! --syn -m conntrack --ctstate NEW -j DROP
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL NONE -j LOG \
    --log-prefix "Stealth scan: "
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL NONE -j DROP
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL ALL -j LOG \
    --log-prefix "Stealth scan: "
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL ALL -j DROP
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL FIN,URG,PSH -j LOG \
    --log-prefix "Stealth scan: "
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j LOG \
    --log-prefix "Stealth scan: "
$IPT -A bad_tcp_packets -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
$IPT -A bad_tcp_packets -p tcp --tcp-flags SYN,RST SYN,RST -j LOG \
    --log-prefix "Stealth scan: "
$IPT -A bad_tcp_packets -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
$IPT -A bad_tcp_packets -p tcp --tcp-flags SYN,FIN SYN,FIN -j LOG \
    --log-prefix "Stealth scan: "
$IPT -A bad_tcp_packets -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
$IPT -A bad_tcp_packets -p tcp -j RETURN
$IPT -A icmp_packets --fragment -p ICMP -j LOG \
    --log-prefix "ICMP Fragment: "
$IPT -A icmp_packets --fragment -p ICMP -j DROP
$IPT -A icmp_packets -p ICMP -s 0/0 --icmp-type 8 -j DROP
$IPT -A icmp_packets -p ICMP -s 0/0 --icmp-type 11 -j ACCEPT
$IPT -A icmp_packets -p ICMP -j RETURN
$IPT -A udp_inbound -p UDP -s 0/0 --destination-port 137 -j DROP
$IPT -A udp_inbound -p UDP -s 0/0 --destination-port 138 -j DROP
$IPT -A udp_inbound -p UDP -s 0/0 --source-port 67 --destination-port 68 \
     -j ACCEPT
$IPT -A udp_inbound -p UDP -j RETURN
$IPT -A udp_outbound -p UDP -s 0/0 -j ACCEPT
$IPT -A tcp_inbound -p TCP -j RETURN
$IPT -A tcp_outbound -p TCP -s 0/0 -j ACCEPT
echo "Process INPUT chain ..."
$IPT -A INPUT -p ALL -i $LO_IFACE -j ACCEPT
$IPT -A INPUT -p ALL -j bad_packets
$IPT -A INPUT -p ALL -d 224.0.0.1 -j DROP
$IPT -A INPUT -p ALL -i $INET_IFACE -m conntrack --ctstate ESTABLISHED,RELATED \
     -j ACCEPT
$IPT -A INPUT -p TCP -i $INET_IFACE -j tcp_inbound
$IPT -A INPUT -p UDP -i $INET_IFACE -j udp_inbound
$IPT -A INPUT -p ICMP -i $INET_IFACE -j icmp_packets
$IPT -A INPUT -m pkttype --pkt-type broadcast -j DROP
$IPT -A INPUT -m limit --limit 3/minute --limit-burst 3 -j LOG \
    --log-prefix "INPUT packet died: "
echo "Process FORWARD chain ..."
echo "Process OUTPUT chain ..."
$IPT -A OUTPUT -p icmp -m conntrack --ctstate INVALID -j DROP
$IPT -A OUTPUT -p ALL -s $LO_IP -j ACCEPT
$IPT -A OUTPUT -p ALL -o $LO_IFACE -j ACCEPT
$IPT -A OUTPUT -p ALL -o $INET_IFACE -j ACCEPT
$IPT -A OUTPUT -m limit --limit 3/minute --limit-burst 3 -j LOG \
    --log-prefix "OUTPUT packet died: "
echo "Load rules for nat table ..."
echo "Load rules for mangle table ..."
###############################################

Colorear la salida de ls:
$ cat .bashrc
alias ls="ls --color"
alias ll="ls -l --color"

Lo copiamos a root
# cp .bashrc /root/


Instalar un paquete con slackpkg
# slackpkg install chromium


Instalar LibreOffice es
# slackpkg search libreoffice

# slackpkg install libreoffice-5.2.1 libreoffice-l10n-es-5.2.1 libreoffice-dict-es-5.2.1

# slackpkg install webcore-fonts-installer

Instalar flashplayer-plugin
# slackpkg install flashplayer-plugin


Crear la base de datos de slocate
# slocate -u

Redirigir errores salida standard para omitir en pantalla

# find / -iname xinitrc 2>/dev/null


Antes de realizar un update-all ver los cambios en el archivo Changelog.txt
# slackpkg check-updates

Actualizar el sistema
# slackpkg upgrade-all

Como hemos actualizado el kernel el sistema nos pregunta si queremos actualizar lilo, le decimos que no porque nuestro sistema es uefi y utiliza elilo.

$ vim /etc/fstab


Ejecutar eliloconfig (si no lo hace no arrancara el sistema con el nuevo kernel)
# eliloconfig

# slackpkg check-updates

No news... is good news

Esto quiere decir que no hay cambios en ChangeLog.txt

Manejador de new config files de Slackware:


Alternativamente podemos utilizar find para encontrar los archivos .new
# find /etc/ *.new
blacklist.new
mirrors.new

Actualizar KDE 5 Plasma
Un proceso sencillo gracias al trabajo de Eric Hameleers alias alienbob y documentado en el archivo README o README.html. Es el archivo que Eric Hameleers (alienbob) mantiene actualizado. Las cosas que pueden cambiar estarán en el README del día que realice la actualización.

Imprescindible no estar ejecutando KDE o cualquier entorno X. Haga un cierre de sesion (log out) y cambie al nivel de ejecución (runlevel) 3 tecleando init 3 si esta en runlevel 4 (grafical login). Luego ejecute los camandos del archivo README desde la consola.

Dicho esto, hago un resumen de la actualización que yo he realizado en octubre del 2016.

Si inicia con startx (/etc/inittab):

 These are the default runlevels in Slackware:
#   0 = halt
#   1 = single user mode
#   2 = unused (but configured the same as runlevel 3)
#   3 = multiuser mode (default Slackware runlevel)
#   4 = X11 with KDM/GDM/XDM (session managers)
#   5 = unused (but configured the same as runlevel 3)
#   6 = reboot

# Default runlevel. (Do not set to 0 or 6)
id:3:initdefault:

Actualizar KDE 5 Plasma desde KDE 4.14.3

# removepkg /var/log/packages/*-4.14.3-*
# removepkg libkscreen
# removepkg kscreen
# removepkg kactivities
# removepkg kde-workspace
# removepkg libmm-qt
# removepkg libnm-qt
# removepkg plasma-nm
#removepkg polkit-kde-agent-1
# removepkg polkit-kde-kcmodules-1
# removepkg kdeconnect-kde
# removepkg kdepimlibs

Más fácil aún es la utilización de Slackpkg y antes deseleccionar los paquetes que quiere conservar (Amarok, Calligra, k3b, etc):
# slackpkg remove kde

Descargar los archivos precompilados necesarios utilizando rsync (Alternativamente puede utilzar lftp)
Necesito los paquetes x86_64 por tanto excluyo los x86, no olvide el punto final
$ mkdir alien
$ cd alien
$ rsync -av --exclude=x86 rsync://alien.slackbook.org/alien/ktown/current/5 .


$ pwd
/home/carles/alien
$ ls
$ README  README.html   x86_64

Ejecutar estos comando como root. Slackware 64-bit:

# upgradepkg --reinstall --install-new x86_64/deps/*.t?z
# upgradepkg --reinstall --install-new x86_64/deps/telepathy/*.t?z
# upgradepkg --reinstall --install-new x86_64/kde/*/*.t?z

Para instalar el paquete de idioma español
# upgradepkg --install-new x86_64/kdei/kde-l10n-es-16.08.0-noarch-1alien.txz

Si tiene el paquete de idioma instalado
# upgradepkg x86_64/kdei/*.t?z

Procesar los "*.new" archivos con
# slackpkg new-config

Por  último y no menos importante tiene que ejecutar 'xwmconfig'
# xwmconfig
y seleccione 'xinitrc.plasma' como su session desktop.


Reiniciar
user name: carles
password
# startx

slackware-live-edition

Unix es genial!.

domingo, 25 de septiembre de 2016

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

sábado, 24 de septiembre de 2016

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

sábado, 27 de agosto de 2016

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!

domingo, 17 de julio de 2016

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