19 de octubre de 2010

BackTrack4 persistente en un USB cifrado: Modificaciones en el arranque

Anteriormente hemos creado las particiones, las hemos cifrado y utilizados con LVM para crear volúmenes lógicos e instalado el sistema operativo. En esta última entrada paso a describir las modificaciones necesarias para que arranque desde la unidad USB y pueda acceder a la información cifrada que contiene.

Es necesario conocer el UUID de la partición cifrada y guardarlo (en un documento de texto, en otra consola, el portapapeles...)

vol_id /dev/sdb5
[...]
ID_FS_UUID=550e8400-e29b-41d4-a716-446655440000
[...]

Lo siguiente que vamos a hacer es montar las particiones y enjaularlas con chroot para poder actualizar el sistema, editar los archivos de configuración o realizar cualquier otra modificación. Inicialmente creamos la carpeta donde montar el sistema.

mkdir /mnt/backtrack4
# Montamos el volumen lógico raíz
mount /dev/mapper/vg-root /mnt/backtrack4
# Montamos la partición /boot
mount /dev/sdb1 /mnt/backtrack4/boot

Ahora nos enjaulamos en el sistema con el siguiente comando; podemos notar que hemos accedido dado que se modifica el pront de la consola, pasando de la almohadilla (#) a la raíz (/).

chroot /mnt/backtrack4

Una vez dentro de la jaula, montamos el sistema de archivos proc y sys con los comandos:

mount -t proc proc /proc
mount -t sysfs sys /sys

Actualizamos la lista de paquetes y los paquetes obsoletos:

aptitude update
aptitude safe-upgrade

Instalamos los paquetes hashalot y lvm2 dado que anteriormente los hemos instalado en el sistema live pero no en el recién instalado en la memoria USB.

aptitude install hashalot lvm2

Ahora necesitamos una serie de scripts con los que poder ejecutar la partición cifrada en el arranque del dispositivo. Accedemos al directorio /etc/initramfs-tools/hooks y descargamos el script hooks-pvcrypt* y le damos permisos de ejecución. Este script copiará los archivos necesarios a la imagen initrd.

cd /etc/initramfs-tools/hooks
wget -O pvcrypt http://www.infosecramblings.com/hooks-pvcrypt
chmod +x pvcrypt

Hacemos lo mismo en el directorio /etc/initramfs-tools/scripts/local-top para el script local-top-pvcrypt*. Este script abrirá la partición cifrada solicitando previamente la frase de paso.

cd /etc/initramfs-tools/scripts/local-top
wget -O pvcrypt http://www.infosecramblings.com/local-top-pvcrypt
chmod +x pvcrypt

Editamos el script para indicarle el UUID que anteriormente hemos guardado, podemos utilizar el editor de texto con el que trabajemos mejor.... Al final del script aparece el comando para abrir el contenedor cifrado pvcrypt:

/sbin/cryptsetup luksOpen /dev/disk/by-uuid/UUID pvcrypt

Modificamos "UUID" por el de la partición quedando de la siguiente manera:

/sbin/cryptsetup luksOpen /dev/disk/by-uuid/550e8400-e29b-41d4-a716-446655440000 pvcrypt

Modificamos el archivo /etc/initramfs-tools/modules para añadir al kernel los módulos criptográficos aes y xts:

vim /etc/initramfs-tools/modules
[...]
aes_i586
xts
[...]

y actualizamos (reconstruimos) la imagen de inicio RAM para que se cargen los scripts descargados y los módulos del kernel anteriores.

update-initramfs -u

Ejecutamos el comando fix-splash que nos creará un nuevo archivo con las opciones de arranque, menu.lst, con los comandos:

cd /etc/initramfs-tools/scripts/local-top
fix-splash

Ahora arrancamos desde la unidad USB para comprobar que todo funciona correctamente y nos loguemos en el sistema como root con la pass toor

shutdown -r now

Un saludo, Brixton Cat ;).

17 de octubre de 2010

BackTrack4 persistente en un USB cifrado: Instalación del sistema

En la entrada anterior estuvimos preparando el dispositivo USB para la instalación de BackTrack4 R1 en el mismo, hemos cifrado con LUKS dicha memoria y creado dos volúmenes lógicos: uno para swap y otro para / (raíz).

Ejecutamos el script install.sh situado en /root el cual nos abrirá una ventana con el asistente de la instalación. En primer lugar deberemos de pulsar siguiente (forward) y en la siguiente ventana seleccionamos nuestra localización: Madrid.

En el siguiente paso especificamos el layout del teclado (Spain-Spain) y una vez hecho esto, pasamos a seleccionar las particiones que utilizará el sistema: seleccionamos la opción Manual y pulsamos siguiente. Inicialmente seleccionamos el volumen lógico /dev/mapper/vg-root y editamos la partición quedando:

Sistema de archivos - Ext3 journaling file system
Formatear la partición - Marcamos el check
Punto de montaje - / (Raíz)

Y seleccionamos la partición destinada al arranque (en mi caso, /dev/sdb1) y editamos la partición de la siguiente manera:

Sistema de archivos - Ext3 journaling file system
Formatear la partición - Marcamos el check
Punto de montaje - /boot

Pulsamos siguiente. En este punto, deberemos especificar el lugar donde se encuentra el cargador de arranque (bootloader), en nuestro caso GRUB se encuentra en /deb/sdb. Para ello, pulsamos en "Advanced" y buscamos en el menu desplegable nuestra memoria USB. Por último pulsamos en "Install" para que comience la instalación del sistema.

Cuando finalice el proceso de instalación, en la ventana que nos aparece seleccionamos la opción "Continue using the live CD".  En la siguiente y última entrega, modificaremos el arranque del sistema para permitir el acceso a la parte cifrada del disco.

Un saludo, Brixton Cat.

16 de octubre de 2010

BackTrack4 persistente en un USB cifrado: Preparando la unidad USB

Utilizando una máquina virtual con el live-DVD Backtrack 4 R1, en primer lugar voy a preparar la unidad USB con las distintas particiones y el cifrado que vamos a utilizar posteriormente con LVM. Primero debemos conocer el nombre del dispositivo. En mi caso, una memoria Kingston de 16GB para tener sitio de sobra para guardar lo que haga falta...

dmesg | grep -E "hd|sd"

Luego ejecutamos fdisk para ver y modificar el particionamiento del mismo, en mi caso sdb

fdisk /dev/sdb

La idea es sencilla, crearemos dos particiones: una destinada a /boot y otra para / (raíz) en la que se instalará el sistema. Los pasos a seguir son:

+ p. Observamos el particionamiento
+ d. Borramos todas las particiones
+ n. Nueva partición:
  - p. Partición primaria
  - 1. Nº de partición
  - 1. Primer cilindro (por defecto)
  - +120M. Último cilindro (partición /boot)
+ t. Código de formato
  - 83. Sistema de archivos Ext3
+ n. Nueva partición:
  - e. Partición extendida
  - 2. Nº de partición
  - xx. Primer cilindro disponible (por defecto)
  - xxx. Último cilindro disponible (por defecto, a no ser que se quiera seguir otro esquema de particionamiento)
+ n. Nueva partición:
  - l. Partición lógica
  - xx. Primer cilindro disponible (por defecto)
  - xxx. Último cilindro disponible (por defecto, a no ser que se quiera seguir otro esquema de particionamiento)
+ a. Marcamos la partición activa
  - 1. Nº de la partición
+ w. Guardamos cambios

Hasta aquí nada del otro mundo, ahora deberemos instalar algunos paquetes necesarios para cifrar la memoria y para crear los distintos volúmenes lógicos, estos son: hashalot y lvm2.

aptitude update
aptitude install hashalot lvm2

Vamos a utilizar el mapeador de dispositivos dm-crypt a través de la herramienta cryptosetup que facilita su uso y Linux Unified Key Setup (LUKS), una implementación del cifrado de disco utilizando PBKDF2 para generar claves derivadas seguras que podrán ser aplicadas a otras herramientas.

Iniciamos la partición a cifrar y configuramos la contraseña de acceso; luego arrancamos dicha partición y creamos el nombre del dispositivo que será mapeado por dm-crypt tras introducir la frase de paso. Podemos introducir la clave en un archivo con la opción --key-file.

cryptsetup -y --cipher aes-xts-plain --key-size 512 luksFormat /dev/sdb5

explicación:
-y --> Verificación de la contraseña
--cipher aes-xts-plain --> Tipo de cifrado
--key-size 512 --> Tamaño de la clave
luksFormat -->Extensión LUKS
/dev/sdb5 --> Partición

cryptsetup luksOpen /dev/sdb5 pvcrypt

explicación:
luksOpen --> Extensión LUKS
/dev/sdb5 --> Partición
pvcrypt --> Nombre del dispositivo a mapear

Una vez tenemos creada la partición cifrada, vamos a iniciar el volúmen físico que utilizaremos con LVM posteriormente. El esquema a configurar es el siguiente:


Iniciamos el volumen físico pvcrypt que vamos a utilizar con LVM:

pvcreate /dev/mapper/pvcrypt

Creamos el grupo de volúmenes vg asociado al volúmen físico anterior:

vgcreate vg /dev/mapper/pvcrypt

Y por último creamos los volúmenes lógicos asociados al grupo de volúmenes anterior:

lvcreate -n swap -L 512M vg
lvcreate -n root -L 14G vg

Generándose los archivos vg-swap y vg-root en la ruta /dev/mapper. Como último paso, deberemos formatear los volúmenes lógicos con los comandos:

mkswap /dev/mapper/vg-swap
mkfs.ext3 /dev/mapper/vg-root

En la próxima entrega instalaremos el sistema operativo en los volúmenes que acabamos de preparar. Es un paso sencillo con algunos matices que hay que comentar para la correcta instalación.

Un saludo, Brixton Cat ;)

15 de octubre de 2010

BackTrack4 persistente en un USB cifrado: Introducción

En la siguiente entrada voy a describir los pasos a seguir para crear una unidad cifrada en la que instalar de forma persistente BackTrack 4 R1 que se detallará en posteriores para intentar que todo quede bien documentado.



Decir que yo no he inventado nada en el siguiente tutorial, es una traducción/interpretación del how-to Install BackTrack Persistent to USB with full disk encryption (también video) disponible desde la página de documentación de dicha distribución.

Las secciones en la que voy a  dividir el tutorial son:

- Preparando la unidad USB

La primera parte la dedicaremos a preparar las particiones de la unidad USB y crearemos el contenedor que cifraremos con LUKS y los volúmenes lógicos en los que instalaremos el sistema operativo.

- Instalando el sistema

Esta entrada va a ser la más simplona porque se describirá el proceso de instalación realizado a través del script install.sh situado en el $HOME de root.

- Modificaciones en el arranque

Por último, modificaremos el arranque para poder acceder a la información cifrada de la memoria USB y comprobaremos que todo funciona correctamente.

Espero que sea de ayuda y utilidad para todo el mundo, en caso de cualquier pregunta no duden en ponerse en contacto conmigo.

Un saludo, Brixton Cat.

6 de marzo de 2010

Script para comprobar la conexión lan

Hace algunos días tuve problemas para navegar por internet por era causa de los DNS que no respondian y se me ocurrió hacer un script que compruebe la conexión tanto del host, del router como de los DNS que tenga configurados. Esta información la recopila a patir de los comandos: ifconfig, route y del archivo de configuración "/etc/resolv.conf"; por lo que son necesarios permisos de root para poder ejecutarlo.

Una vez ha recuperado dicha información y la ha confirmado el usuario, se pasa a un bucle for que lanza un paquete ICMP (ping -c 1) a las direcciones que comprobar. Las respuestas se guardan en un archivo temporal con el que filtrar los resultados: parquetes enviados y recibidos, perdidos, etc... Se crea un segundo archivo temporal que muestra por pantalla los resultados obtenidos según la opción que se eliga.

Por último, prueba la resolución de nombres lanzando nuevamente un paquete ping al dominio www.google.es o al dominio que espeficiquemos nosotros.

Esto solamente es una idea, tengo en mente que se pueda especificar el direccionamiento del equipo para aplicarlo y hacer pruebas. También hacer una lista con los DNS de varios ISP para incorporarlo al bucle y que pruebe la conexión hasta dichos equipos; entre otras cosas mas: consola nslookup, dig, nmap¿?...

El código es:
#!/bin/bash
#
# SCRIPT TO CHECK YOURS CONECTIONS
#
function net {
        ipl=`ifconfig | grep -E "inet[^6]" | grep -v 127| awk '{print $2}' | sed s/[a-zA-Z:]*//`
        msk=`ifconfig | grep -E "inet[^6]" | grep -v 127 | awk '{print $4}' | sed s/[a-zA-Z:]*//`
        gtw=`route | grep default | awk '{print $2}'`
        int=`route | grep default | awk '{print $8}'`
        dns1=`cat /etc/resolv.conf | grep -v "#" | grep -n "" | grep "1:" | awk '{print $2}'`
        dns2=`cat /etc/resolv.conf | grep -v "#" | grep -n "" | grep "2:" | awk '{print $2}'`
}
#
function conect {
        for i in $ipr; do
         ping -c 1 $i > temp
         ip=`cat temp | grep -oE "PING [0-9.]+" | awk '{print $2}'`
         env=`cat temp | grep -oE "[0-9]+ packets transmitted" | awk '{print $1}'`
         rec=`cat temp | grep -oE "[0-9]+ received" | awk '{print $1}'`
         per=`cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}'`
         los=`expr $env - $rec`
         echo -e "IP destino: $ip"
         echo -e "Paquetes enviados: $env"
         echo -e "Paquetes recibidos: $rec"
         echo -e "Paquetes perdidos: $los"
         echo -e "Perdidas: $per"
         if [[ `cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}' | sed s/\%//` == 0 ]]; then
             echo -e OK
         else
             echo -e OPS!
         fi
         echo -e "-----------------------"
        done
}
#
net
echo -ne "Creo que esta es tu configuracion de red:\n\tInterfaz: $int\n\tIP: $ipl\n\tMascara: $msk\n\tGateway: $gtw\n\tDNS 1: $dns1\n\tDNS 2: $dns2\nEs correcto (s/n): "
read resp
if [[ $resp == s || $resp == S ]]; then
    ipr=`echo "$ipl $gtw $dns1 $dns2"`
elif [[ $resp == n || $resp == N ]]; then
    echo -e "Hasta otra..."
    exit 1
else
    echo -e "Debes responder si o no... vuelve a internarlo ;)"
    exit 1
fi
clear
echo -e "Probando conectividad..."
conect > temp2
echo -ne "RESULTADOS:\n-----------\n\t1) $int\n\t2) $gtw\n\t3) $dns1\n\t4) $dns2\n\t*) Cualquier otra tecla para verlos todos\nElige el numero asociado al resultado que quieras ver: "
read report
case $report in
    1)
      clear
      cat temp2 | grep -A 5 `echo $ipl`
      ;;
    2)
      clear
      cat temp2 | grep -A 5 `echo $gtw`
      ;;
    3)
      clear
      cat temp2 | grep -A 5 `echo $dns1`
      ;;
    4)
      clear
      cat temp2 | grep -A 5 `echo $dns2`
      ;;
    *)
      clear
      more temp2
      ;;
esac
echo -e "\nQuieres probar la resolucion de nombres?\nEscribe la pagina web con la que quieras comprobar los servidores DNS\n[www.google.es]"
read resp
if [ -z $resp ]; then
    ping -c 1 www.google.es > temp
elif [ $resp = `echo $resp | grep -oE "www\.[a-z.]+\.[a-z.][a-z.]+"` ]; then
    ping -c 1 $resp > temp
else
    ping -c 1 www.google.es > temp
fi
echo -e "Ping a: `cat temp | grep -oE "PING www\.[a-z.]+\.[a-z.][a-z.]+" | awk '{print $2}'`"
echo -e "Perdidas: `cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}'`"
if [[ `cat temp | grep -oE "[0-9]+% packet loss" | awk '{print $1}' | sed s/\%//` == 0 ]]; then
    echo -e OK
else
    echo -e OPS!
fi
rm -rf temp*
exit 0
#
#Fve
El script como no, se licencia bajo GPLv3. Un saludo, Brixton Cat ;)

PD: Si alguien tiene algún problema con el script o porque no se entienda bien por el formato del blog, no duden en comentar o pedir una copia del mismo.

Crear Live-USB de BackTrack 4 con PlayFullDrive

Hace tiempo que no escribo una entrada dado que ultimamente estoy liado todo el día con algún editor de texto y una consola en la que probar scripts... En la última versión del script que tengo entre manos, PlayFullDrive beta 0.2.1, se puede utilizar la última release de BackTrack, BackTrack 4 Final.

Dado que BackTrack 4 utiliza GRUB como cargador de arranque y yo utilizo Syslinux para dicha función a la hora de crear los lives, esta distribución tiene ligeras diferencias con el resto de lives compatibles con el script. Por poner algún ejemplo, el archivo de configuración "menu.lst", la imagen splash "bt4.xpm.gz", etc... Por ello, debemos de modificar dichos archivos para que puedan trabajar con Syslinux.

Inicialmente deberemos lanzar el script como si de otra live se tratase y como se lanzan todos los scripts: lo descargamos, descomprimimos y lanzamos.

wget http://sourceforge.net/projects/playfulldrive/files/playfulldrive0.2.1.tar.gz
tar xvfz playfulldrive0.2.1.tar.gz
chmod +x playfulldrive0.2.1.sh
./playfulldrive0.2.1.sh

En la pantalla inicial, se nos muestran tres opciones para elegir: predefinidas, local e internet. Para nuestro caso, podemos tanto elegir la primera como la segunda teniendo en cuenta que para las imagenes predefinidas, se descargará una imagen de la distribución al menos que en el mismo directorio ya contemos con ella.


Una vez hemos descargado o indicado la ruta de la imagen iso a utilizar, nos pide que introduzcamos la unidad usb para ser reconocida y formateada. Cuando la unidad está lista, monta el usb y la imagen en dos carpetas temporales desde la que copiar los archivos a la unidad. Es posible que muestre varios fallos con algunas distribuciones pero después arranca la unidad y se trabajar con el live.



Utilizando "bt4-final.iso" como nombre del archivo de imagen, mostrará un mensaje anunciando que son necesarios los archivos de arranque antes de desmontar las unidades y finalizar el script. Dichos archivos están disponibles en la url:

http://sourceforge.net/projects/playfulldrive/files/boot_backtrack.tar.gz

y contienen la imagen splash, el archivo de configuración syslinux.cfg y el archivo vesamenu.c32, un kernel para crear menus de arranque interactivos.

En el archivo "doc-bt4.txt", adjuntado en la última versión del paquete, se detalla el proceso de creación de dichos archivos. Éste, también está disponible en la url:

http://sourceforge.net/projects/playfulldrive/files/doc-bt4.txt

Un saludo, Brixton Cat ;)

31 de enero de 2010

Playfulldrive beta 0.1

Quiero presentarles a Playfulldrive beta 0.1. Un script en bash que acaba de ver la luz del día y que poco a poco esperemos valla ampliando capacidades y tenga una buena acogida entre el público. Se trata de un script que encontré buscando información por Internet y que con permiso del autor modifiqué para darle más opciones. El mismo autor fue quién me propuso hacer un proyecto en Sourceforge para que estuviera a disposición de toda la comunidad y ahora ya es un hecho ;)

La dirección donde encontrar información y las distintas releases que vayan saliendo es

http://sourceforge.net/projects/playfulldrive/

y en ella podreis dejar comentarios sobre vuestra experiencia, exponer bugs que encontreis o discutir el código o live-cd que fallan, etc... entre otras opciones.

En el mismo menu podemos elegir entre algunas distribuciones archiconocidas dentro del mundillo de la seguridad: Ophcrack, Wifislax y Wifiway. La idea es seguir probando distribuciones y añadir las que sean de uso común dentro de la comunidad. El script está licenciado bajo la General Public License v3, de la que se acompaña una copia junto con un archivo README donde se describe el programa, las distintas opciones, su funcionamiento, etc...

Todavía faltan muchas cosas por hacer, pensar y probar; pero paso a paso se hace el camino no? Por último, agradecer a j8k6f4v9j que me dejase toquetear su código y me incitase a crear este proyecto y a todos los demás curiosos que quieran probar el script. Para la próxima, un pequeño manual del uso del programa.

Playfulldrive beta 0.1
http://downloads.sourceforge.net/project/playfulldrive/playfulldrive0.1.tar.gz

Un saludo, Brixton Cat ;)