Preparar un entorno de trabajo con wmctrl

wmctrl es un programa que nos va a ayudar a generar un entorno de trabajo en el que usamos una serie de aplicaciones de forma habitual con un layout concreto.

El ejemplo siguiente funciona sobre Gnome 3 que genera de forma dinámica los escritorios virtuales (workspaces) por lo que habrá que jugar también con el comando sleep para darle tiempo a crear nuevos workspaces.

En el ejemplo se creará un entorno con una terminal, el IDE de programación Pida, un navegador, dos ventanas y Rhythmbox para escuchar música.

#!/bin/bash
# primer escritorio
wmctrl -s 0
pida &
iceweasel &
terminator --working-directory=/home/javi/Escritorio/PFC -l pfc &
sleep 5s
wmctrl -x -F -r "terminator.Terminator" -e 0,842,0,1078,1080
wmctrl -x -F -r "pida.Pida" -e 0,0,0,840,1047
wmctrl -x -F -r "Navigator.Iceweasel" -e 0,1920,369,1280,742
wmctrl -r "Iceweasel" -t 0

#segundo escritorio
nautilus /home/javi/Escritorio/PFC &
sleep 2s; 
wmctrl -F -r "PFC" -e 0,2150,330,871,638 
wmctrl -F -r "PFC" -t 1

#tercer escritorio
nautilus /home/javi/Escritorio/PFC/Documentación &
sleep 2s; 
wmctrl -r "Documentación" -e 0,2150,330,871,638 
wmctrl -r "Documentación" -t 2

#cuarto escritorio
rhythmbox &
sleep 3s; 
wmctrl -xF -r "rhythmbox.Rhythmbox" -e 0,1920,369,1280,742
wmctrl -xF -r "rhythmbox.Rhythmbox" -t 3
exit 0

Como se puede ver hay que dejar tiempos de espera con sleep para que haya tiempo para lanzarse la aplicación o crearse el workspace virtual por parte de Gnome 3.
En algunos casos se ha usado el parámetro -x la ventana usando la clase del programa cuando el programa sustituye su nombre en el título de la ventana por otro texto (caso Pida). En otros se ha usado -r que busca dicha cadena en el título de la ventana.
El parametro -F obliga a buscar estrictamente la cadena (case sensitive)

Por último, este script se puede guardar en un directorio del path como ~/bin para poder ejecutarlo fácilmente usando Alt+F2 en Gnome.

Abrir y cerrar el acceso desde el exterior por SSH usando gtalk

En la Raspberry Pi recibo diariamente desde China varios cientos de intento de acceso al servicio SSH. Aprovechando el post anterior vamos a modificar algo el script external para hacer que el acceso a SSH desde el exterior esté abierto o cerrado a voluntad. Indicaremos con una orden vía gtalk a Raspberry Pi que abra o cierre el puerto, algo similar a lo que se haría con port-knocking.

En external añadimos las siguientes líneas:

ssh.abre)
    /usr/local/bin/ssh.abre; 
    ;;
ssh.cierra)
   /usr/local/bin/ssh.cierra; 
   ;;

Enviando los comandos ssh.cierra y ssh.abre se añadirá o eliminará una regla en Iptables. Para esto hace falta crear un par de scripts que irán en /usr/local/bin
ssh.abre:

#!/bin/sh
# ssh.abre por ratoncio
sudo iptables -I INPUT -p tcp --dport 22 -j ACCEPT
echo "Abierto el acceso por SSH";

ssh.cierra:

#!/bin/sh
# ssh.cierra por ratoncio
num=$(sudo iptables -L -n --line-numbers|grep "tcp dpt:22"|awk '{print $1}')
/usr/local/bin/iptables.remove "$num";
echo "Cerrando el acceso exterior por SSH";

Ahora se puede indicar a Raspberry cuando queremos acceder desde el exterior de nuestra red local por SSH.

Control de raspberry usando gtalk

El objetivo es enviar comandos y recibir información de la raspberry pi usando gtalk.
Para esto usaremos centerim; un programa que permite mediante consola conectarse a varios servicios de IM como gtalk. Para dejar este programa en segundo plano emplearemos screen.

Por defecto RaspBMC tiene las preferencias de apt-get configuradas para que instale los paquete extras. Debido a esto se produce una instalación de 250MB y que para colmo rompe el servicio XBMC. Para evitar esto se edita el fichero /etc/apt/apt.conf y se añaden las líneas:

APT::Install-Recommends "0";
APT::Install-Suggests "0";

Tras esto instalamos:

apt-get install centerim screen

Una vez instalado se ejecuta centerim con el usuario que se usará para arrancarse normalmente. En mi caso, pi.
En la opción jab se rellenan las opciones de la cuenta gmail que usaremos para la Raspberry. Una vez hecho esto se creará una estructura de directorios que se podrá editar:
home/pi/.centerim/
En el fichero config tendremos que tener algo similar a esto:

jab_nick    cuentapararaspberrypi@gmail.com
jab_pass    contraseña
jab_server  talk.google.com:5223
jab_osinfo  1
jab_prio    4
jab_ssl     1

Para arrancar el sistema automaticamente se añade la siguiente línea a /etc/rc.local

su pi -c 'screen -dmS centerim /usr/bin/centerim'

Ahora configuraremos el fichero external que está en el directorio .centerim
El siguiente ejemplo es el mío que realiza varias acciones:

%action         Remote control
event           msg
proto           all
status          all
options         stdin stdout

%exec
#!/bin/sh
# script de mayordomo gtalk-raspberry pi por ratoncio
ENTRADA=`cat`;
# el comando se fuerza a minusculas para evitar problemas con las mayusculas automaticas de los moviles
COMANDO=`echo $ENTRADA|awk '{print $1}'|tr '[:upper:]' '[:lower:]'`;
RESTO=`echo $ENTRADA|awk -F "$COMANDO " '{print $2}'`;
if [ $CONTACT_NICK = aquifiltropormipropiacuentade@gmail.com ]; then
case $COMANDO in
        df) df -h;;
        uptime) uptime;;
        vmstat) vmstat;;
        who) w;;
        mem) free -m;;
        dmesg)
            dmesg |tail -n 20
                    echo "----";
            echo "Fin dmesg";
        ;;
        apunta|nota)
            echo "Apunto esto: $RESTO";
            echo "$RESTO" >> /home/pi/notasRTN;
        ;;
        notas)
            #cat /home/pi/notasRTN;
            echo;
            i=1;while read linea;do echo "$i: $linea";i=`echo $i +1|bc`;done</home/pi/notasRTN;
            echo "----";
            echo "No hay mas notas";
            ;;
        borranota)
            sed "$RESTO"d /home/pi/notasRTN > /tmp/notasRTN.tmp;
            mv /tmp/notasRTN.tmp /home/pi/notasRTN;
            rm /tmp/notasRTN.tmp;
            echo "Borrada nota $RESTO";
        ;;
        diag)
            /opt/vc/bin/vcgencmd measure_temp;
            /opt/vc/bin/vcgencmd measure_volts;
        ;;
        torrent)
            echo "torrent (start|stop|status)";
            /etc/init.d/transmission-daemon $RESTO;
        ;;
	    hora)
            echo "Son las `date +%H:%M:%S`";
        ;;
        biblioteca)
            echo "biblioteca (start|stop)";
            /home/pi/calibre-server $RESTO;
        ;;
        ayuda|help)
            echo "Soy Ratoncio, tu asistente electronico. Los comandos validos son:";
            echo ;
            echo "df";
            echo "uptime";
            echo "vmstat";
            echo "who";
            echo "dmesg";
            echo "agenda";
            echo "apunta";
            echo "notas";
            echo "borranota";
		    echo "servicios";
		    echo "diag";
		    echo "torrent";
		    echo "hora";
		    echo "biblioteca (start|stop)";
            echo "ayuda";
        ;;
        *)
		    echo "Has dicho: $ENTRADA";
		    echo "----";
		    echo "Lo siento, no entiendo tu pregunta. Prueba con 'ayuda'.";
        ;;
    esac
fi;

Convertir comics en formato pdf a formato cbz

Para una visión más cómoda. Con este sencillo script que requiere poppler-utils

# pdf2cbz: Conversor de formato para comics por ratoncio
#!/bin/bash
for i in *.pdf;do
echo "************";
echo "$i";
echo "************";
mkdir "${i%.pdf}";
pdfimages -j "$i" "${i%.pdf}"/0;
zip -r "${i%.pdf}".cbz "${i%.pdf}";
rm -rf "${i%.pdf}";
done

El siguiente para convertir de cbr a cbz

# cbr2cbz: Conversor de formato para comics por ratoncio
#!/bin/bash
for i in *.cbr;do
echo "************";
echo "$i";
echo "************";
mkdir "${i%.cbr}";
unrar e "$i" "${i%.cbr}";
zip -r "${i%.cbr}".cbz "${i%.cbr}";
rm -rf "${i%.cbr}";
done

Enviar Pop-ups informativos a XBMC

Esto nos permitirá sacar Pop-ups en la interfaz de XBMC. Realmente sencillo usando la interfaz que nos proporciona XBMC (JSON-RPC API). Lo colocaremos en /usr/local/bin para acceso general.

Vamos con el script en cuestión: msgtoxbmc

# msgtoxbmc: script para enviar pop ups a XBMC por ratoncio
#!/bin/bash
# procesado del pipe
case "$#" in
0)
        mensaje=`cat`
;;
*)
        mensaje="$@"
;;
esac;
# codigo envio
mensajeenviar=`echo $mensaje|sed 's/\ /\%20/g'`
titulo="Informacion%20de%20Ratoncio"
wget -qO- "http://192.168.1.124:8080/jsonrpc?request={%22jsonrpc%22:%222.0%22,%22method%22:%22GUI.ShowNotification%22,%22params%22:{%22title%22:%22$titulo%22,%22message%22:%22$mensajeenviar%22},%22id%22:1}" &> /dev/null
#habla "`echo $mensaje|sed 's/\%20/\\ /g'`"
exit 0;

La invocación, sencilla, por parámetros o usando pipe:

  • msgtoxbmc mensaje de prueba
  • echo mensaje de prueba|msgtoxbmc

Si en el script se descomenta la línea penúltima (habla) se oiría el mensaje por la TV (usando el script habla del post anterior)

Síntesis de voz en Raspberry Pi con RaspBMC

Algo muy sencillo de lograr y que nos permitirá jugar un poco.
Los pasos son los siguientes:
Instalar espeak y alsa utils

aptitude update
aptitude install espeak alsa-utils

La salida de audio por defecto con RaspBMC es por HDMI pero es necesario cargar el módulo snd_bcm2835. Lo añadimos al fichero /etc/modules

Ahora, en las opciones de salida de audio de XBMC hay que poner que el dispositivo de audio este activo siempre. Por defecto sólo está activo un minuto con lo que no nos funcionaría más que la primera vez.

Para facilitar las cosas hacemos un pequeño script en bash (habla)que pondremos en /usr/local/bin para acceso general con los permisos necesarios.

#!/bin/bash
# Script para sintesis voz por consola por ratoncio

case "$#" in
0)
        cat|espeak -ves > /dev/null 2>&1
;;
*)
        echo "$@"|espeak -ves > /dev/null 2>&1
;;
esac
exit 0;

El script se puede invocar con parámetros o pipe:

  • habla hola que tal
  • echo hola que tal | habla
  • Actualización: debido a un error en el paquete espeak se puede usar este script alternativo:

    #!/bin/bash
    # Script para sintesis voz por consola por ratoncio
    FILE="/tmp/habla-$RANDOM.wav"
    case "$#" in
        0)
            cat|espeak -ves -w $FILE 
            ;;
        *)
            echo "$@"|espeak -ves -w $FILE 
            ;;
    esac
    play -q "$FILE" >/dev/null 2>&1
    rm "$FILE";
    exit 0;
    

    Para que funcione es necesario instalar sox

    apt-get install sox
    

    Servidor completo usando Raspberry Pi

    Introducción y objetivos

    El objetivo de este post es crear un completo servidor casero que permita gestionar varios servicios usando una Raspberry Pi. Este servidor se conectará a la televisión de casa mediante el puerto HDMI y a internet mediante el router y nos permitirá entre otras cosas:

    • Gestionar desde el móvil la descarga de contenidos vía torrent.
    • La reproducción vídeo y audio en la TV de casa usando el móvil como control.
    • Streaming de vídeo y audio a cualquier dispositivo que se conecte a la red de casa; DLNA
    • La gestión de una biblioteca electrónica de libros y comics permitiendo su acceso fácil a ella a dispositivos móviles tipo tablets o libros electrónicos.
    • Descarga automática de capítulos de series

    Raspberry Pi es un pequeño ordenador basado en arquitectura ARM con grandes posibilidades que corre un sistema basado en GNU/Linux.

    Los servicios básicos que queremos tener son los siguientes:

    • Apache: servidor web para servir de interfaz de varios de los servicios.
    • Calibre: para la gestión de una biblioteca electrónica.
    • Transmission: para la descarga de torrents.
    • XBMC: para disponer de un completo entorno multimedia.
    • sickbeard: para la descarga automática de capítulos de una serie.

    En mis pruebas he utilizado dos distribuciones diferentes de Linux adaptadas a Raspberry Pi ambas basadas en Debian: Raspbian y Raspmc. Debido a los problemas que supone la instalación de XBMC en Raspbian es recomendable usar Raspbmc.

    Hardware para el sistema

    Tras haber realizado varias pruebas voy a usar el siguiente hardware:

    • Una Raspberry Pi
    • Un adaptador de red inalámbrica USB para la conexión al router
    • Un cable HDMI para la conexión a la TV
    • Una tarjeta SD para instalar el arranque del sistema operativo de la Raspberry Pi
    • Una memoria USB para la instalación del sistema operativo
    • Un disco duro externo para el almacenamiento de los datos (vídeo, audio, etc)

    Uno de los pasos claves del proceso es el separar el arranque del sistema operativo del resto del SO en lugar de instalar ambos en una tarjeta SD como es el procedimiento estándar. En mi experiencia, el uso de torrents hace que el número de escrituras sobre la tarjeta SD la corrompa rápidamente. El uso de una memoria USB mejora el rendimiento y evita este problema. Una opción es particionar el disco duro externo para instalar en él el sistema operativo de la Raspberry Pi y también los datos.

    Sobre Raspbmc y su instalación

    Raspbmc es una distribución de Linux basada en debian. Su gran ventaja es que viene ya preparada con una instalación funcional de XBMC lo que simplifica en gran medida los quebraderos de cabeza que suponen instalar este programa.Hay varias formas de instalar Raspbmc en una tarjeta SD. El método que recomiendo es descargar el script python install.py de http://www.raspbmc.com/wiki/user/os-x-linux-installation/ y seguir las instrucciones.
    Este método facilita mucho la instalación de raspbmc y nos llevaría a tener instalado Raspbmc en la tarjeta SD, sin embargo, se va a mover el SO a un USB para usar sólo la SD como arranque (/boot). La instalación del sistema en el USB es tan simple como introducir una memoria USB en el momento de arrancar por primera vez la Raspberry Pi.

    Instalación y configuración de software adicional

    Vía apt se instalará transmission, apache y calibre

    apt-get update
    apt-get install transmission-daemon apache2 calibre
    

    Se cambia el nombre de host

    vi /etc/hostname
    mihost
    vi /etc/hosts
    se sustituye raspbmc por mihost mihost.noip.me en el loopback 127.0.1.1
    

    Configuración de apache2

    En la ruta /etc/apache2/sites-available se editará el fichero default
    vi /etc/apache2/sites-available/default

    <VirtualHost *:80>
            ServerAdmin pi@ratoncio.no-ip.org
    
            DocumentRoot /var/www
            <Directory />
                    Options FollowSymLinks
                    AllowOverride None
            </Directory>
            <Directory /var/www/>
                    Options Indexes FollowSymLinks MultiViews
                    AllowOverride None
                    Order allow,deny
                    allow from all
            </Directory>
            <Directory /var/www/ficheros/>
                    Options Indexes FollowSymLinks MultiViews
                    AllowOverride AuthConfig
                    Order allow,deny
                    allow from all
            </Directory>
            <Directory /var/www/biblioteca/>
                    Options Indexes FollowSymLinks MultiViews
                    AllowOverride All
                    Order allow,deny
                    allow from all
            </Directory>
    
            ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
            <Directory "/usr/lib/cgi-bin">
                    AllowOverride None
                    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
                    Order allow,deny
                    Allow from all
            </Directory>
    
            ErrorLog ${APACHE_LOG_DIR}/error.log
    
            # Possible values include: debug, info, notice, warn, error, crit,
            # alert, emerg.
            LogLevel warn
    
            CustomLog ${APACHE_LOG_DIR}/access.log combined
    
            #para calibre y transmission
            RewriteEngine on
    
            ProxyPass /descargas/ http://localhost:9999/descargas/
            ProxyPass /descargas http://localhost:9999/descargas
            SetEnv force-proxy-request-1.0 1
            SetEnv proxy-nokeepalive 1
    </VirtualHost>
    

    Se habilitan los mods de apache necesarios para hacer rewrite, necesario para poder redirigir a distintos puertos calibre y transmission desde apache.

    a2enmod proxy rewrite proxy_http
    

    Se crea la estructura web en /var/www
    Se crea un directorio en /var/www/biblioteca con usuario y grupo www-data

    Configuración de calibre

    En la ruta /home/pi se crea un script calibre-server que permitirá lanzar y parar calibre en modo server. Calibre correrá en un puerto al que se redirigirá desde la página web que servimos con apache.

    #!/bin/bash
    export LANG=es_ES.UTF-8
    if [ $# -eq 1 ];then
    case $1 in
    start)
    calibre-server --with-library=/media/Almacen/biblioteca/ --daemonize --port 10001 --url-prefix /biblioteca ;
    echo "La biblioteca esta abierta";
    ;;
    stop)
    #killall calibre-server;
    kill -9 `ps -fea|grep calibre-server|grep -v grep|awk '{print $2}'`;
    echo "La biblioteca esta cerrada";
    ;;
    status)
    RESUL=`ps aux|grep -v grep|grep "calibre-server"|wc -l`;
    if [ $RESUL -eq 0 ];then
    echo "La biblioteca esta cerrada";
    else
    echo "La biblioteca esta abierta";
    fi;
    ;;
    *)
    echo "Opciones: start|stop"
    ;;
    esac;
    fi;
    

    El control de acceso se hace mediante un fichero .htaccess que se encuentra en /var/www/biblioteca con este contenido:

    AuthUserFile /home/pi/pass-htaccess-apache
    AuthType Basic
    AuthName "Haz login"
    Require user javi mariola
    Options +FollowSymLinks
    RewriteEngine on
    RewriteRule (.*) http://localhost:10001/biblioteca/$1 [proxy]
    

    Se puede ver que el script lanza en modo daemon calibre en el puerto 10001 con la ruta que hayamos configurado con la biblioteca. Al acceder vía web a la ruta mihost.noip.me/biblioteca se nos redirigirá al server corriendo en el puerto 10001 con calibre.

    Configuración de transmission-daemon

    Para emplear torrents se configurará transmission-daemon.

    Se edita el fichero /var/lib/transmission-daemon/info/settings.json (es un enlace a /etc/transmission-daemon/settings.json). Para que este fichero se edite correctamente el servidor transmission debe estar parado así:

    service transmission-daemon stop

    {
        "alt-speed-down": 50,
        "alt-speed-enabled": true,
        "alt-speed-time-begin": 420,
        "alt-speed-time-day": 127,
        "alt-speed-time-enabled": true,
        "alt-speed-time-end": 0,
        "alt-speed-up": 10,
        "bind-address-ipv4": "0.0.0.0",
        "bind-address-ipv6": "::",
        "blocklist-enabled": false,
        "blocklist-url": "http://www.example.com/blocklist",
        "cache-size-mb": 4,
        "dht-enabled": true,
        "download-dir": "/media/Almacen/transmission-daemon/downloads",
        "download-limit": 100,
        "download-limit-enabled": 0,
        "download-queue-enabled": true,
        "download-queue-size": 12,
        "encryption": 0,
        "idle-seeding-limit": 30,
        "idle-seeding-limit-enabled": false,
        "incomplete-dir": "/media/Almacen/transmission-daemon/incomplete",
        "incomplete-dir-enabled": false,
        "lpd-enabled": false,
        "max-peers-global": 200,
        "message-level": 2,
        "peer-congestion-algorithm": "",
        "peer-limit-global": 300,
        "peer-limit-per-torrent": 60,
        "peer-port": 51413,
        "peer-port-random-high": 65535,
        "peer-port-random-low": 49152,
        "peer-port-random-on-start": false,
        "peer-socket-tos": "default",
        "pex-enabled": true,
        "port-forwarding-enabled": true,
        "preallocation": 1,
        "prefetch-enabled": 1,
        "queue-stalled-enabled": true,
        "queue-stalled-minutes": 30,
        "ratio-limit": 2,
        "ratio-limit-enabled": false,
        "rename-partial-files": true,
        "rpc-authentication-required": true,
        "rpc-bind-address": "0.0.0.0",
        "rpc-enabled": true,
        "rpc-password": "contraseniaservicio",
        "rpc-port": 9999,
        "rpc-url": "/descargas/",
        "rpc-username": "descargas",
        "rpc-whitelist": "127.0.0.1",
        "rpc-whitelist-enabled": false,
        "script-torrent-done-enabled": true,
        "script-torrent-done-filename": "/var/lib/transmission-daemon/script/avisaTorrent",
        "seed-queue-enabled": false,
        "seed-queue-size": 10,
        "speed-limit-down": 350,
        "speed-limit-down-enabled": false,
        "speed-limit-up": 20,
        "speed-limit-up-enabled": true,
        "start-added-torrents": true,
        "trash-original-torrent-files": false,
        "umask": 18,
        "upload-limit": 100,
        "upload-limit-enabled": 0,
        "upload-slots-per-torrent": 14,
        "utp-enabled": true,
        "watch-dir": "/media/Almacen/transmission-daemon/blackhole",
        "watch-dir-enabled": true
    
    }
    
    

    A continuación se edita el fichero /etc/init.d/transmission-daemon y se indica en USER que el usuario será pi

    Y se hace chown -R pi:pi /var/lib/transmission-daemon/* y chown pi:pi /etc/transmission-daemon/settings.json

    Configuración de NFS

    Hacer que cargue nfs en el arranque.

    apt-get install nfs-kernel-server
    update-rc.d rpcbind defaults
    update-rc.d nfs-common defaults
    update-rc.d nfs-kernel-server defaults
    

    Se definen los exports

    /media/Almacen *(ro,sync,no_subtree_check,insecure,all_squash,anonuid=0,anongid=0)
    

    Se refrescan los exports
    exportfs -ra

    Configuración Sickbeard

    sudo apt-get install git-core
    git clone git://github.com/echel0n/SickBeard-TVRage.git /var/local/sickbeard
    cd /var/local/sickbeard
    python SickBeard.py -d
    

    Sickbeard arranca en el puerto 8081. En un navegador entramos en dicha dirección y seleccionamos config y general.
    Desactivar Launch Browser pues el acceso será web.
    En web interface se puede configurar un user, passwd y nuevo puerto. Solo cambiaré el puerto por otro (20001) pues la autenticación la hago con htacess
    En search providers se chequean los gratuitos sin cuenta ( NZBs, Sick Beard y Womble)
    En post processing se quita la opción de keep original files y se marcan las move associated files y rename episodes. En name pattern seleccionamos «s02e03 – Ep Name»
    En metadata seleccionamos XBMC (12+ pues la versión de Raspbmc equivale a la 12 o superior) y chequeamos los metadatos (todos menos los season all)
    En config notifications seleccionamos XBMC y chequeamos notify on download, update library, introducimos la ip y el puerto (192.168.1.124:1234)
    En search options, torrent search activamos la búsqueda de torrents, el método blackhole y definimos una ruta para el directorio blackhole (/media/Almacen/transmission-daemon/blackhole)
    Ya se puede trabajar seleccionando add existing shows si ya tenemos parte de la serie descargada o add shows si aún no.

    Recuperar un Grub al fallar la instalación

    Arrancar desde una live distro. Se puede configurar una fácilmente usando unetbootin en un USB.

    Montar la partición con /boot en algún directorio. Pej. /mnt/debian

    
    grub-install --root-directory=/mnt/debian/ /dev/sda
    
    

    Rearrancar. Debería aparecer un prompt así: grub>

    linux /boot/vmlinuz-x.x.x-x-xxxxxx root=/dev/sdXY ro

    initrd /boot/initrd.img-x.x.x-x-xxxxx

    boot

    Una vez haya arrancado el sistema

    
    grub-install
    
    update-grub2
    
    

    Encriptado de partición home: cryptsetup y luks

    Lo he obtenido de http://disonanciamental.dyndns.org

    Si bien esto vale para cifrar la partición home, en mi caso he preferido cifrar únicamente un directorio «Documentos» de mi home que es donde guardo la información sensible.
    He usado una partición libre de 20GB /dev/sda2 donde se guardará la información cifrada.
    Se comienza por instalar cryptsetup y libpam-mount para montar las particiones.

    aptitude install cryptsetup libpam-mount
    

    Se cargan los modulos para no reiniciar

    modprobe -a aes dm_mod dm_crypt sha256
    

    Se actualiza pam para activar pam-mount:

    pam-auth-update
    

    Se crea la partición cifrada con la contraseña de nuestro usuario (para que el proceso de montaje sea transparente vía pam)

    cryptsetup luksFormat /dev/sda2
    

    Se le cambia el nombre a la partición. En mi caso «Documentos» para que después al montarse los enlaces de Gnome 3 sigan teniendo «Documentos» como nombre. Esto lo hice con el editor de particiones/discos de gnome.

    cryptsetup luksOpen /dev/sda2 crypt-home
    

    Se da formato a la partición.

    mkfs.ext4 /dev/mapper/crypt-home
    

    Se copian los datos a dicha partición

    mount /dev/mapper/crypt-home /mnt/
    rsync -tarv /home/user/ /mnt/
    

    Se indica a pam-mount el punto de montaje

    vi /etc/security/pam_mount.conf.xml
    

    Bajo «Volume definitions» se añade

    <volume user="ratoncio" fstyp="crypt" path="/dev/sda2" mountpoint="/home/ratoncio" />
    

    Al iniciar con el usuario se cargará automáticamente la partición cifrada de con los documentos.

    Por último, para cambiar la contraseña se haría lo siguiente:
    Se busca la clave que está en uso en los slots. Si nunca se ha hecho esto, lo más probable es que sea el slot 0

    cryptsetup luksDump /dev/sda2
    

    Se añade una nueva clave. Se pedirá una de las claves en uso, en este caso la única que existe, la del slot 0.

    cryptsetup luksAddKey /dev/sda2
    

    Se borra la clave anterior. Esto sólo funciona si al menos hay otra clave creada.

    cryptsetup luksKillSlot /dev/sda2 0 
    

    cURL – Obtener datos con formularios en https y procesarlos.

    Supongamos el siguiente escenario (real en mi caso):

    Tenemos que obtener diariamente datos de una página web. Dicha página usa SSL para su protección y se pasan los parámetros de una búsqueda en un formulario mediante POST. A partir de estos parámetros se obtiene unos resultados de dicha búsqueda que es lo que queremos procesar en un fichero de texto posteriormente.

    Realizar consultas con cURL a servicios que usan sistemas de autenticación es relativamente sencillo. Este proceso se complica si el sitio destino usa cookies para gestionar la seguridad.

    Para llegar a la resolución de este problema hay que realizar la operación en dos pasos: en uno se generarán y obtendrán las cookies de la sesión, en otro se usarán estas cookies para generar la consulta.

    1.- Obtener cookies.

    Empleando la extensión de firefox tamper data (extensión muy recomendable si no se conoce) se captura el post que se realiza para conocer los parámetros que envía el formulario. Aquí se ve que se piden tres parámetros para la autenticación: store, user, pwd.

    Con estos creamos el primer formulario que se enviará vía post al sitio. Los formularios post se codifican usando URL encoding y cada parámetro se separa con &. El fichero quedaría así:

    authform:

    store=tienda&user=miusuario&pwd=mipassword&Entrar=Aceptar
    

    Ahora habrá que lanzar cURL para generar el acceso y capturar las cookies que genere el sitio. Esto se realiza de la siguiente forma:

    curl -d @authform -H "Content-Type:application/x-www-form-urlencoded;charset=UTF-8" https://servidordestinoconSSL -c cookie.txt -vk1
    

    El parámetro -v simplemente da más información. El parametro -k sirve para evitar problemas con la verificación de certificados y el -1 es para forzar el uso de SSL (era necesario en mi caso). cURL usa por defecto SSL3 (al menos en mi caso y en este momento).

    Con esto hemos obtenido un fichero cookie.txt que contiene las cookies de sesión generadas y que nos servirán para las siguientes consultas.

    2.- Realización de la búsqueda.

    Volvemos a emplear tamper data para calcular los parámetros del formulario de búsqueda del servicio y replicamos el formulario como antes.

    searchform:

    FechaDesde=12%2F10%2F2012+00%3A00%3A00&Estado=0&Tipo=0&FechaHasta=13%2F10%2F2012+00%3A00%3A00&NumFilas=99&RefCompra=Pan=&CodAutorizacion=
    

    Nótese que los parámetros vacíos también están en dicho fichero.

    Ahora se manda dicho formulario con cURL enviando también las cookies de sesión:

    curl -d @searchform -H "Content-Type:application/x-www-form-urlencoded;charset=UTF-8" https://servidordestinoconSSL -vk1 -b cookie.txt  -o salida.html
    

    El parámetro -b es el fichero de cookies y el -o hace que la salida se guarde en un fichero para después realizar el parsing.

    3.- Parsing y formato de los datos:

    En mi caso, la salida es una tabla en formato HTML, así que este es el parsing particular que hice para obtener en un texto claro los datos de salida con una línea por fila de tabla. Se puede ver como se quitan los retornos de carro y las etiquetas de la tabla para dejar después las líneas separadas por un fin de línea.

    cat salida.html |grep -E "TD>|TR>" |tail -n +6 |head -n -2 |tr -d '\r\n'|sed 's/<TR>//g'|sed 's/<\/TR>/\n/g'|sed 's/<TD>//g'|sed 's/<\/TD>/\ /g'|sed 's/<B>//g'|sed 's/<\/B>//g' > salidaparseada
    
    Crea tu propio sitio web gratis en WordPress.com.Crear tu propio sitio web.
    Empezar gratis