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

Anuncios

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

wr – script para consultar términos en inglés en Wordreference


#!/bin/sh
# buscador múltiple de word reference
# introducir wr seguido de los terminos a buscar en inglés

echo RESULTADOS DE BUSQUEDA DE:
echo $1
vartratada=`echo $1|sed 's/\ /_/g'`
echo  ++++++++++++++++++++++++++++++++++++++++++++
echo  WORD REFERENCE: $1
echo  ++++++++++++++++++++++++++++++++++++++++++++"\n"
wget http://wordreference.com/es/translation.asp\?tranword=$1\&dict=enes\&B10=Search -U mozilla -q -O /tmp/wordref$vartratada
html2text -utf8 -o /tmp/wordref$vartratada.txt /tmp/wordref$vartratada
cat /tmp/wordref$vartratada.txt|tail -n +20|head -n 20
rm /tmp/wordref$vartratada /tmp/wordref$vartratada.txt

rae – script para consultar términos en el diccionario de la RAE

#!/bin/bash
# buscador del diccionario de la RAE

TEMP=$RANDOM
echo "RESULTADOS DE BUSQUEDA DE: $1"
vartratada=`echo $1|sed 's/\ /_/g'|sed 's/á/\%e1/g'|sed 's/é/\%e9/g'|sed 's/í/\%ed/g'|sed 's/ó/\%f3/g'|sed 's/ú/\%fa/g'|sed 's/Á/\%c1/g'|sed 's/É/\%c9/g'|sed 's/Í/\%cd/g'|sed 's/Ó/\%d3/g'|sed 's/Ú/\%da/g'|sed 's/ñ/\%f1/g'|sed 's/Ñ/\%d1/g'`
echo  ++++++++++++++++++++++++++++++++++++++++++++
echo  Diccionario RAE: $1
echo  ++++++++++++++++++++++++++++++++++++++++++++
# antigua URL
#        wget buscon.rae.es/draeI/SrvltGUIBusUsual\?LEMA=$1\&origen=RAE\&TIPO_BUS=3 -q -U mozilla -O /tmp/rae$vartratada
wget lema.rae.es/drae/srv/search\?type=3\&val=$vartratada\&origen=RAE -q -U mozilla -O /tmp/rae$TEMP
html2text -utf8 -o /tmp/rae$TEMP.txt /tmp/rae$TEMP
cat /tmp/rae$TEMP.txt|head -n 24
rm /tmp/rae$TEMP /tmp/rae$TEMP.txt

Envío múltiple de ficheros con netcat

Valga esto como curiosidad. Lo uso para evitar el uso de scp que pide contraseña al transferir archivos (habitualmente sale más a cuenta hacer un tar con los archivos y buscar la contraseña para el scp).

Supongamos que queremos enviar entre hostorigen y hostdestino 10 archivos: file0-file9.

En hostdestino:

for i in `seq 0 9`;do nc -l 3000 > file"$i";done

Se ejecuta primero esto.

En hostorigen:

for i in `seq 0 9`;do cat file"$i"|nc hostdestino 3000;sleep 2s;done

El sleep es la parte crucial, hace que espere dos segundos para que el hostdestino tenga tiempo de sobra de entrar en el siguiente ciclo de escucha en netcat.

Por supuesto, al depender de un temporizador para realizar la “sincronización” este proceso no es a prueba de fallos. Lo dicho, una curiosidad más que algo realmente práctico.

progbar y progbar2: barras de progreso en bash

Para añadir algo de animación a los scripts que pueden tardar en ejecutarse, nada mejor que una barra de progreso personalizada.
En este ejemplo, la barra rebota al estilo gnome y Kitt (coche fantástico).

#!/bin/bash
# progbar: una barra de progreso en bash
# por ratoncio
# ver. 0.1
SPEED=0.1
DEL="\\x08\\x08\\x08\\x08\\x08\\x08\\x08\\x08"
PID=$1
while [ -d /proc/$PID ];do
    echo -en "0-------" && sleep $SPEED && echo -en $DEL
    echo -en "-0------" && sleep $SPEED && echo -en $DEL
    echo -en "--0-----" && sleep $SPEED && echo -en $DEL
    echo -en "---0----" && sleep $SPEED && echo -en $DEL
    echo -en "----0---" && sleep $SPEED && echo -en $DEL
    echo -en "-----0--" && sleep $SPEED && echo -en $DEL
    echo -en "------0-" && sleep $SPEED && echo -en $DEL
    echo -en "-------0" && sleep $SPEED && echo -en $DEL
    echo -en "------0-" && sleep $SPEED && echo -en $DEL
    echo -en "-----0--" && sleep $SPEED && echo -en $DEL
    echo -en "----0---" && sleep $SPEED && echo -en $DEL
    echo -en "---0----" && sleep $SPEED && echo -en $DEL
    echo -en "--0-----" && sleep $SPEED && echo -en $DEL
    echo -en "-0------" && sleep $SPEED && echo -en $DEL
done
echo -en $DEL"        "$DEL
exit 0

Se lanza el proceso en segundo plano y la barra de progreso en función del PID del proceso
sleep 5s & progbar $!

Se puede incluir como función en un script o usarse de forma externa (como está en este ejemplo)

El siguiente ejemplo es una versión modificada algo más personalizable en la que se puede pasar como parámetro la longitud deseada de la barra.

#!/bin/bash
# una barra de progreso en bash
# por ratoncio
# ver. 0.2

if [ $# -gt 1 ];then
    BARLENGTH=`echo $2-1|bc`
    SPEED=0.1
    DELCAR="\\x08"
    PID=$1
    BARCAR="-"
    CAR="0"
    CONT=0
    SWITCH=0
    for i in `seq 0 $BARLENGTH`;do
        BAR=$BAR$BARCAR
        DEL=$DEL$DELCAR
    done
    
    while [ -d /proc/$PID ];do
        if [ $SWITCH -eq 0 ];then
            echo -en "${BAR:0:$CONT}$CAR${BAR:$CONT+1:$BARLENGTH}" && sleep $SPEED && echo -en $DEL
            CONT=`echo $CONT + 1|bc`
        else
            echo -en "${BAR:0:$CONT}$CAR${BAR:$CONT+1:$BARLENGTH}" && sleep $SPEED && echo -en $DEL
            CONT=`echo $CONT - 1|bc`
        fi
        if [ $CONT -eq $BARLENGTH -o $CONT -eq 0 ];then
            if [ $SWITCH -eq 0 ];then
                SWITCH=1
            else
                SWITCH=0
            fi
        fi 
    done
    echo -en $DEL"        "$DEL
    exit 0
else
        echo "progbar <pid> <longitudbarra>"
        exit 1
fi

Se lanza el proceso en segundo plano y la barra de progreso en función del PID del proceso y de la longitud deseada (en el ejemplo, 10)
sleep 5s & progbar $! 10