VirtIT

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
======Full Disk Encryption sous Arch Linux (busybox)======

:!: Ce document est une méthode que je considère déprécié. je préconise maintenant [[kb:linux:données:Full Disk Encryption sous Arch Linux (systemd)]]. Cette nouvelle méthode est plus simple et plus rapide.

=====Introduction=====

Cette documentation permet d'installer Arch Linux avec du chiffrement intégrale du disque dur en mode EFI.


^ AVANTAGE                                       ^ INCONVENIENT                                   ^
| Chiffrement intégrale, même le /boot           | La clé de chiffrement stocké à la racine        |
| Utilisation de l'EFI                           | Lent au démarrage                  |
| Une seule passphrase à taper au boot           | Gros problème de compatibilité entre le layout et les clavier USB                 |
| L'"hibernation" du système est fonctionnelle et chiffrée          |                       | 

Cette solution repose sur un chiffrement par passphrase de la partition **/boot**, et du chiffrement des autres partitions par clé de chiffrement stocké dans l'image **INITRAMFS** (qui est stocké dans la partition **/boot**)


Voici l'agencement des partitions utilisé dans cette documentation. La seule réel contrainte sont les deux partitions **/boot** et **/boot/efi** :
<code>
+----------------------+-----------------------+-----------------------+-----------------------+
|ESP partition:        |Partition Boot:        |Partition Root:        |Partition SWAP         |
|                      |                       |                       |                       |
|/boot/efi             |/boot                  |/                      |[SWAP]                 |
|                      |                       |                       |                       |
|                      |/dev/mapper/cryptoboot |/dev/mapper/cryptoroot |/dev/store/cryptoswap  |
|                      |UUID=<UUID-VOL-BOOT>   |UUID=<UUID-VOL-ROOT>   |UUID=<UUID-VOL-SWAP>   |
|                      +-----------------------+-----------------------+-----------------------+
|/dev/sda1             |/dev/sda2              |/dev/sda3              |/dev/sda4              |
|UUID=<UUID-PART-ESP>  |UUID=<UUID-PART-BOOT>  |UUID=<UUID-PART-ROOT>  |UUID=<UUID-PART-SWAP>  |
|non-chiffré           |chiffré                |chiffré                |chiffré                |
+----------------------+-----------------------+-----------------------+-----------------------+
</code>


=====Installation=====

===Boot en mode EFI===

Il vous faut boot en mode EFI, pour vérifier, le dossier **/sys/firmware/efi/efivars/** doit exister

===Changer le Layout du clavier===

Vu qu'en France nous avons un clavier AZERTY, il faut le changer pour se simplifier la vie :

<code>
# loadkeys fr
</code>

===Se connecter à Internet===

Là je vous renvoie vers la documentation officiel, ce sujet est bien trop exhaustif

===Partitionnement des disques===

Pour cela, je vous renvoie vers de la documentation de [[https://doc.ubuntu-fr.org/fdisk|fdisk]] 

Il faut ensuite mettre le système de fichier FAT32 sur la partition **/boot/efi**

<code>
# mkfs.fat -F32 /dev/sda1
</code>

puis on va chiffré la partition **/boot** avec une PassPhrase : 

<code>
# cryptsetup luksFormat /dev/sda2
</code>

Ensuite on va créer une clé de chiffrement pour les autres partitions:

<code>
# dd if=/dev/urandom of=crypto_keyfile.bin bs=512 count=4
</code>

Puis on chiffre les autres partitions ainsi que la partition boot avec cette dites clé

<code>
# cryptsetup luksAddKey /dev/sda2 crypto_keyfile.bin
# cryptsetup luksFormat /dev/sda3 crypto_keyfile.bin
# cryptsetup luksFormat /dev/sda4 crypto_keyfile.bin
</code>

Maintenant on va les déchiffrés :

<code>
# cryptsetup open /dev/sda2 cryptboot
# cryptsetup open /dev/sda3 cryptroot --key-file=crypto_keyfile.bin
# cryptsetup open /dev/sda4 cryptswap --key-file=crypto_keyfile.bin
</code>

puis de les formater :

<code>
# mkfs.ext4 /dev/mapper/cryptboot
# mkfs.ext4 /dev/mapper/cryptroot
# mkswap /dev/mapper/cryptswap
</code>

puis on les montes :

<code>
# mount /dev/mapper/cryptroot /mnt/
# mkdir /mnt/boot
# mount /dev/mapper/cryptboot /mnt/boot/
# mkdir /mnt/boot/efi
# mount /dev/sda1 /mnt/
</code>

===Installation de Arch Linux===

On va commencer par choisir notre miroir pour les dépots Arch en modifiant le fichier **/etc/pacman.d/mirrorlist** en sélectionnant le pays de son choix

On va ensuite mettre a jour les clés des packet

<code>
# pacman -Sy archlinux-keyring
</code>

et enfin on installe Arch en lancant :

<code>
# pacstrap /mnt base base-devel
</code>

On y copie la clé de chiffrement :

<code>
# cp crypto_keyfile /mnt
</code>

puis on se chroot pour faire la configuration:

<code>
# arch-chroot /mnt
</code>

===Configuration de Arch===

On commence par configurer le time zone :

<code>
# ln -sf /usr/share/zoneinfo/Europe/Paris /etc/localtime
# hwclock --systohc
</code>

Puis on génère le langage français :

<code>
# echo "fr_FR.UTF-8 UTF-8" > /etc/locale.gen && locale-gen && echo "LANG=fr_FR.UTF-8" > /etc/locale.conf && echo "KEYMAP=fr" > /etc/vconsole.conf
</code>

Puis on installe les paquets utiles :

<code>
# pacman -Syu efibootmgr grub
</code>


Ensuite on configure le nom d'hôte dans le fichier **/etc/hostname** :

<code>
Arch-0000
</code>

ainsi que le fichier **/etc/hosts** :

<code>
127.0.0.1	localhost.localdomain	localhost
::1		localhost.localdomain	localhost
127.0.1.1	Arch-0000.localdomain	Arch-0000
</code>

===Configuration du boot===

On modifie le fichier **/etc/default/grub**, il faut modifié cet ligne comme tel:

<code>
GRUB_CMDLINE_LINUX_DEFAULT="cryptdevice=UUID=<UUID-PART-SDA3>:cryptroot resume=UUID=<UUID-VOL-CRYPTOSWAP>"
</code>

ainsi que la ligne suivante:

<code>
GRUB_TERMINAL_INPUT=at_keyboard
</code>

et pour finir décommente la ligne : 

<code>
GRUB_ENABLE_CRYPTODISK=y
</code>

on ajoute dans le fichier /etc/grub.d/40_custom :

<code>
insmod keylayouts
keymap /boot/grub/fr.gkb
</code>

et on copie le fichier {{ :kb:linux:donnees:fr.gkb |fr.gkb}} dans le dossier **/boot/grub/**

Ensuite on génère la config grub :

<code>
# grub-mkconfig -o /boot/grub/grub.cfg
# grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=LINUX --recheck
</code>

Puis régénère le RAMDISK EFI de grub pour qu'il ajoute le clavier :

<code>
# grub-mkstandalone -d /usr/lib/grub/x86_64-efi/ -O x86_64-efi --modules="part_gpt part_msdos crypto cryptodisk luks disk diskfilter" -o "/boot/efi/EFI/LINUX/grubx64.efi" "boot/grub/grub.cfg=/boot/grub/grub.cfg" "boot/grub/fr.gkb=/boot/grub/fr.gkb"
</code>

Maintenant on va générer l'image **initramfs** pour le déchiffrement, pour cela il faut aller modifier le fichier **/etc/mkinitcpio.conf** en modifiant le champ **HOOKS** de cet manière :

<code>
HOOKS=(base udev autodetect modconf keyboard keymap block encrypt openswap resume filesystems fsck)
</code>

ainsi que le champ **FILES** comme ceci :

<code>
FILES=(/crypto_keyfile.bin)
</code>

Ensuite on va créer le HOOK openswap, donc on va créer le fichier **/etc/initcpio/install/openswap** comme ceci :

<code file openswap>
build ()
{
add_runscript
}
help ()
{
cat<<HELPEOF
This opens the swap encrypted partition /dev/sda3 in /dev/mapper/cryptswap
HELPEOF
} 
</code>

ainsi que le fichier **/etc/initcpio/hooks/openswap**

<code file openswap>
run_hook ()
{
cryptsetup open --key-file=/crypto_keyfile.bin /dev/disk/by-uuid/<UUID-PART-SWAP> cryptswap
rm -f /crypto_keyfile.bin
}
</code>

puis on exécute la commande(( Cette commande (et la suivante) devra peut-être être retapé en cas de mise a jour de initcpio. Elle sera nécessaire si vous avez l'erreur "failed to open key file" lors du lancement du hook "openswap" au démarrage )) :

<code>
# sed -i 's/rm -f ${ckeyfile}//g' /usr/lib/initcpio/hooks/encrypt
</code>

puis on génère l'image :

<code>
# mkinitcpio -p linux
</code>

puis on créer le fichier **/etc/crypttab** en ajoutant les volumes suivants :

<code>
cryptoboot     UUID=<UUID-PART-BOOT>     /crypto_keyfile.bin
cryptoroot     UUID=<UUID-PART-ROOT>     /crypto_keyfile.bin
</code>

à noté que le déchiffrement de la partition de la partition **swap** à déjà été réalisé durant le HOOK de l'**initramfs**, d'où son absence dans le fichier.

Et pour finir le fichier **/etc/fstab** :

<code>
UUID=<UUID-PART-ESP>         /boot/efi         vfat        defaults         0 1
UUID=<UUID-VOL-BOOT>         /boot             ext4        defaults         0 1
UUID=<UUID-VOL-ROOT>         /                 ext4        defaults         0 1
UUID=<UUID-VOL-SWAP>         none              swap        defaults         0 2
</code>