tothi/kali-rpi-luks-cryptCifrado de disco completo para Kali en Raspberry usando LUKS
Esta guía está dedicada a ejecutar Kali en Raspberry (u otra arquitectura similar, p. ej. ODROID-C2 usando cifrado de disco completo con LUKS. Basada en el documento un poco desactualizado aquí.
Desplegar Kali en Raspberry Pi (u otro hardware similar, pequeño y de baja potencia) en un entorno LAN como una "hackbox desechable" es obviamente útil. Sin embargo, mantener en secreto los datos recopilados es un requisito esencial. Aquí es donde el cifrado de disco completo entra como un concepto de seguridad obligatorio.
Primero debemos configurar una imagen oficial actual de Kali para Raspberry Pi (sin cifrado) en una tarjeta SD.
La opción recomendada (ahora) es usar una compilación personalizada de Raspberry Pi 3 con el parche nexmon (para usar las capacidades de monitorización e inyección de la WiFi integrada). Hay un script de compilación automatizado en el repositorio oficial kali-arm-build-scripts que prepara la imagen desde cero (en una distro Kali). Y aquí hay una versión parcheada que también funciona en otras distros además de Kali (probada en Gentoo). Actualmente (2017-08) también hay un script de compilación funcional para ODROID-C2 en ese repositorio bifurcado.
Obtén las herramientas de compilación y compila la imagen desde cero como root (puede tardar un par de horas):
$ git clone https://github.com/tothi/kali-arm-build-scripts
$ cd kali-arm-build-scripts
$ sudo ./rpi3-nexmon.sh 2.0
La imagen resultante es rpi3-nexmon-2.0/kali-2.0-rpi3-nexmon.img.xz. Cópiala en la tarjeta SD (usando pv para mostrar el progreso):
# pixz -d rpi3-nexmon-2.0/kali-2.0-rpi3-nexmon.img.xz - | pv -treb | dd of=/dev/mmcblk0 bs=512k
(La imagen debería funcionar; ahora se puede probar).
Montamos la imagen desde la tarjeta SD y preparamos un initramfs capaz de usar funciones LUKS en un entorno chroot. Para que esto funcione, se necesita un binario qemu-arm-static x86 (host) en el sistema de archivos de la tarjeta SD. El script de compilación rpi3-nexmon.sh parcheado anteriormente lo instala y lo deja en la imagen, por lo que todo debería funcionar bien. (De lo contrario, es necesario copiar el binario estático qemu apropiado a la imagen).
Inicializando el entorno chroot (en el sistema host como root):
# mkdir -p /mnt/chroot/boot
# mount /dev/mmcblk0p2 /mnt/chroot/
# mount /dev/mmcblk0p1 /mnt/chroot/boot/
# mount -t proc none /mnt/chroot/proc
# mount -t sysfs none /mnt/chroot/sys
# mount -o bind /dev /mnt/chroot/dev
# mount -o bind /dev/pts /mnt/chroot/dev/pts
# LANG=C chroot /mnt/chroot/
Primero cambiamos la contraseña predeterminada de root:
passwd
Instala los paquetes necesarios (en el entorno chroot):
# apt-get update
# apt-get install busybox cryptsetup dropbear
Ten en cuenta que debemos introducir la clave de descifrado en cada arranque. Preferiblemente lo hacemos de forma remota a través de SSH, por eso se necesita dropbear (en el initramfs).
Ahora edita /boot/cmdline.txt, cambia el dispositivo raíz al dispositivo crypt mapeado (/dev/mapper/crypt_sdcard) y añade el parámetro cryptdevice apropiado.
Así que aquí está un /boot/cmdline.txt original:
dwc_otg.fiq_fix_enable=2 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait rootflags=noload net.ifnames=0
Y aquí está el actualizado (diferencias en los parámetros root y cryptdevice):
dwc_otg.fiq_fix_enable=2 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mapper/crypt_sdcard cryptdevice=/dev/mmcblk0p2:crypt_sdcard rootfstype=ext4 rootwait rootflags=noload net.ifnames=0
Ahora crea /boot/config.txt con el siguiente contenido:
initramfs initramfs.gz followkernel
Ten en cuenta que en otro hardware se necesitan pasos similares (el archivo que contiene los parámetros de arranque en ODROID-C2 es /boot/boot.ini).
Configuremos la autenticación por clave SSH de Dropbear. Crea un par de claves (sin contraseña) en la máquina host (¡fuera del chroot!) y lee la clave pública:
$ ssh-keygen -N "" -f kali-dropbear
$ cat ./kali-dropbear.pub
Añade la clave pública a /etc/dropbear-initramfs/authorized_keys. Restringe el acceso SSH de Dropbear únicamente para configurar cryptroot, anteponiendo a la clave lo siguiente:
command="/scripts/local-top/cryptroot && kill -9 `ps | grep -m 1 'cryptroot' | cut -d ' ' -f 3`"
Corrige los permisos:
chmod 600 /etc/dropbear-initramfs/authorized_keys
Edita /etc/fstab. Original:
# <file system> <mount point> <type> <options> <dump> <pass>
proc /proc proc defaults 0 0
/dev/mmcblk0p1 /boot vfat defaults 0 2
/dev/mmcblk0p2 / ext4 defaults,noatime 0 1
Actualizado: el dispositivo / se cambia a /dev/mapper/crypt_sdcard:
# <file system> <mount point> <type> <options> <dump> <pass>
proc /proc proc defaults 0 0
/dev/mmcblk0p1 /boot vfat defaults 0 2
/dev/mapper/crypt_sdcard / ext4 defaults,noatime 0 1
Añade esta línea a /etc/crypttab:
crypt_sdcard /dev/mmcblk0p2 none luks
Modifica /etc/cryptsetup-initramfs/conf-hook estableciendo
CRYPTSETUP=y
para incluir los archivos de cryptsetup en la imagen initramfs.
Finalmente, genera el initramfs para la versión actual del kernel y sal del chroot (no te preocupes por los errores/advertencias durante mkinitramfs):
# ls -l /lib/modules/ |awk -F" " '{print $9}'
4.4.50-v7+
# mkinitramfs -o /boot/initramfs.gz 4.4.50-v7+
Ten en cuenta que debemos tener cuidado al generar la imagen (especialmente en otro hardware), porque uname -r devuelve la versión del kernel del host, no la del chroot. Así, p. ej. en ODROID-C2 /boot/mkuinitrd no funciona directamente; deberíamos ejecutar manualmente los comandos del script (¡ajustando la versión del kernel PARA OTRO HARDWARE!):
# rm /boot/initrd.img-3.14.79
# update-initramfs -c -k 3.14.79
# mkimage -A arm64 -O linux -T ramdisk -C none -a 0 -e 0 -n "uInitrd" -d /boot/initrd.img-3.14.79 /boot/uInitrd
#
Sal del entorno chroot
exit
Desmonta los sistemas de archivos y haz una copia de seguridad de rootfs antes de crear el volumen cifrado (y borrar todo) en la tarjeta SD:
# umount /mnt/chroot/boot
# umount /mnt/chroot/sys
# umount /mnt/chroot/proc
# mkdir -p /mnt/backup
# rsync -avh /mnt/chroot/* /mnt/backup/
Desmonta el chroot completo:
# umount /mnt/chroot/dev/pts
# umount /mnt/chroot/dev
# umount /mnt/chroot
Elimina la partición raíz sin cifrar (n.º 2) y crea una vacía (ocupando toda la tarjeta SD):
# echo -e "d\n2\nw" | fdisk /dev/mmcblk0
# echo -e "n\np\n2\n\n\nw" | fdisk /dev/mmcblk0
Ahora (probablemente) es necesario desenchufar y volver a insertar la tarjeta SD para registrar las nuevas particiones.
Crea un volumen cifrado con una contraseña segura (¡este paso destruye la rootfs original!):
# cryptsetup -v -y --cipher aes-cbc-essiv:sha256 --key-size 256 luksFormat /dev/mmcblk0p2
# cryptsetup -v luksOpen /dev/mmcblk0p2 crypt_sdcard
# mkfs.ext4 /dev/mapper/crypt_sdcard
Restaura la rootfs al volumen cifrado y cierra el disco:
# mkdir -p /mnt/encrypted
# mount /dev/mapper/crypt_sdcard /mnt/encrypted/
# rsync -avh /mnt/backup/* /mnt/encrypted/
# umount /mnt/encrypted/
# cryptsetup luksClose /dev/mapper/crypt_sdcard
# sync
Expulsa la tarjeta SD y pruébala en la Raspberry.
El primer proceso de arranque fallará y entrará en busybox. Introduce los siguientes comandos:
# cryptsetup luksOpen /dev/mmcblk0p2 crypt_sdcard
## provide password
# exit
Tu dispositivo debería arrancar ahora. Inicia sesión con la contraseña que elegiste antes y ejecuta:
mkinitramfs -o /boot/initramfs.gz
reboot
Ahora se te pedirá la contraseña con un prompt más agradable; además deberías poder hacer ssh al busybox e introducir la contraseña (puedes usar un archivo known_hosts personalizado si lo deseas):
$ ssh -o "UserKnownHostsFile=~/.ssh/known_hosts.initramfs" -i ~/.ssh/kali-dropbear [email protected]
Una vez que funcione, no olvides limpiar los archivos de copia de seguridad en el host:
# rm -fr /mnt/backup
# rm -fr /mnt/chroot
Para obtener una salida de depuración completa durante el arranque, puedes añadir debug=1 en cmdline.txt