tothi/kali-rpi-luks-cryptChiffrement complet du disque pour Kali sur Raspberry avec LUKS
Ce tutoriel est dédié à l'exécution de Kali sur Raspberry (ou autre architecture similaire, par ex. ODROID-C2 avec chiffrement complet du disque avec LUKS. Basé sur le document un peu obsolète ici.
Déployer Kali sur Raspberry Pi (ou autre matériel similaire, petit et peu puissant) dans un environnement LAN en tant que 'boîte à piratage jetable' est évidemment utile. Cependant, garder les données collectées secrètes est une exigence essentielle. C'est là que le chiffrement complet du disque intervient en tant que concept de sécurité obligatoire.
Nous devons d'abord configurer une image Kali officielle actuelle pour le Raspberry Pi (sans chiffrement) sur une carte SD.
L'option recommandée (maintenant) est d'utiliser une construction personnalisée pour Raspberry Pi 3 avec le patch nexmon (pour utiliser les capacités de surveillance et d'injection WiFi intégrées). Il y a un script de construction automatisé dans le dépôt officiel kali-arm-build-scripts qui configure l'image à partir de zéro (sur une distribution Kali). Et voici une version patchée qui fonctionne aussi sur d'autres distributions que Kali (testée sur Gentoo). Actuellement (2017-08), le script de construction fonctionnel pour ODROID-C2 se trouve également ici dans ce dépôt forké.
Obtenez les outils de construction et construisez l'image à partir de zéro en tant que root (cela peut prendre quelques heures) :
$ git clone https://github.com/tothi/kali-arm-build-scripts
$ cd kali-arm-build-scripts
$ sudo ./rpi3-nexmon.sh 2.0
L'image résultante est rpi3-nexmon-2.0/kali-2.0-rpi3-nexmon.img.xz. Copiez-la sur la carte SD (en utilisant pv pour afficher la progression) :
# pixz -d rpi3-nexmon-2.0/kali-2.0-rpi3-nexmon.img.xz - | pv -treb | dd of=/dev/mmcblk0 bs=512k
(L'image devrait fonctionner, elle peut être testée maintenant.)
Nous montons l'image depuis la carte SD et préparons un initramfs capable des fonctionnalités LUKS dans un environnement chroot. Pour que cela fonctionne, un binaire qemu-arm-static x86 (hôte) est nécessaire sur le système de fichiers de la carte SD. Le script de construction patché rpi3-nexmon.sh ci-dessus l'installe et le laisse sur l'image, donc les choses devraient bien fonctionner. (Sinon, la copie du binaire statique qemu approprié sur l'image est nécessaire.)
Initialisation de l'environnement chroot (sur le système hôte en tant que 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/
Nous changeons d'abord le mot de passe par défaut pour root :
passwd
Installez les paquets requis (dans l'environnement chroot) :
# apt-get update
# apt-get install busybox cryptsetup dropbear
Notez que nous devons saisir la clé de déchiffrement à chaque démarrage. Nous le faisons de préférence à distance via SSH, c'est pourquoi dropbear est nécessaire (dans l'initramfs).
Maintenant, éditez /boot/cmdline.txt, changez le périphérique root en périphérique crypté mappé (/dev/mapper/crypt_sdcard) et ajoutez le paramètre cryptdevice approprié.
Voici donc 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
Et voici la version mise à jour (différences dans les paramètres root et 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
Maintenant, créez /boot/config.txt avec le contenu suivant :
initramfs initramfs.gz followkernel
Notez que sur d'autres matériels, des étapes similaires sont nécessaires (le fichier contenant les paramètres de démarrage sur ODROID-C2 est /boot/boot.ini).
Configurons l'authentification par clé SSH Dropbear. Créez une paire de clés (sans mot de passe) sur la machine hôte (en dehors du chroot !) et lisez la clé publique :
$ ssh-keygen -N "" -f kali-dropbear
$ cat ./kali-dropbear.pub
Ajoutez la clé publique à /etc/dropbear-initramfs/authorized_keys. Limitez l'accès SSH Dropbear uniquement pour la configuration de cryptroot en préfixant la clé avec ceci :
command="/scripts/local-top/cryptroot && kill -9 `ps | grep -m 1 'cryptroot' | cut -d ' ' -f 3`"
Corrigez les permissions :
chmod 600 /etc/dropbear-initramfs/authorized_keys
Éditez /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
Périphérique / mis à jour changé en /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
Ajoutez cette ligne à /etc/crypttab :
crypt_sdcard /dev/mmcblk0p2 none luks
Modifiez /etc/cryptsetup-initramfs/conf-hook en définissant
CRYPTSETUP=y
pour inclure les fichiers cryptsetup dans l'image initramfs.
Enfin, créez initramfs pour la version actuelle du noyau et quittez le chroot (ne vous souciez pas des erreurs/avertissements pendant mkinitramfs) :
# ls -l /lib/modules/ |awk -F" " '{print $9}'
4.4.50-v7+
# mkinitramfs -o /boot/initramfs.gz 4.4.50-v7+
Notez que nous devons être prudents lors de la génération de l'image (surtout sur d'autres matériels), car uname -r renvoie la version du noyau de l'hôte, pas celle du chroot. Ainsi, par exemple, sur ODROID-C2, /boot/mkuinitrd ne fonctionne pas directement, nous devons exécuter les commandes du script manuellement (en ajustant la version du noyau POUR D'AUTRES MATÉRIELS !) :
# 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
#
Quittez l'environnement chroot
exit
Démontez les systèmes de fichiers et sauvegardez rootfs avant de créer le volume chiffré (et de tout supprimer) sur la carte SD :
# umount /mnt/chroot/boot
# umount /mnt/chroot/sys
# umount /mnt/chroot/proc
# mkdir -p /mnt/backup
# rsync -avh /mnt/chroot/* /mnt/backup/
Démontez le chroot complet :
# umount /mnt/chroot/dev/pts
# umount /mnt/chroot/dev
# umount /mnt/chroot
Supprimez la partition root non chiffrée (n° 2) et créez-en une vide (remplissant la carte SD) :
# echo -e "d\n2\nw" | fdisk /dev/mmcblk0
# echo -e "n\np\n2\n\n\nw" | fdisk /dev/mmcblk0
Maintenant, (probablement) le débranchement et la réinsertion de la carte SD sont nécessaires pour enregistrer les nouvelles partitions.
Créez un volume chiffré avec une phrase de passe forte (cette étape détruit la rootfs originale !) :
# 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
Restaurer rootfs sur le volume chiffré et fermer le disque :
# 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
Éjectez la carte SD et testez-la sur le Raspberry.
Le premier processus de démarrage échouera et tombera dans busybox. Entrez les commandes suivantes :
# cryptsetup luksOpen /dev/mmcblk0p2 crypt_sdcard
## provide password
# exit
Votre appareil devrait démarrer maintenant. Connectez-vous avec le mot de passe que vous avez choisi plus tôt et exécutez :
mkinitramfs -o /boot/initramfs.gz
reboot
On vous demandera la phrase de passe avec une invite plus agréable, de plus vous devriez pouvoir vous connecter en ssh à busybox et entrer la phrase de passe (vous pouvez utiliser un fichier known_hosts personnalisé si vous le souhaitez) :
$ ssh -o "UserKnownHostsFile=~/.ssh/known_hosts.initramfs" -i ~/.ssh/kali-dropbear [email protected]
Une fois que cela fonctionne, n'oubliez pas de nettoyer les fichiers de sauvegarde sur l'hôte :
# rm -fr /mnt/backup
# rm -fr /mnt/chroot
Pour obtenir une sortie de débogage complète pendant le démarrage, vous pouvez ajouter debug=1 dans cmdline.txt