Un NAS transportable hautement sécurisé

NAS chiffré full open source sur Raspberry Pi 3 transportable : ZFS + LUKS avec déchiffrement via clé USB

Cet article présente un guide pas à pas pour déployer un NAS chiffré sur un Raspberry Pi 3 transportable. Nous combinons la robustesse de ZFS pour la gestion de disques et la résilience des données avec la sécurité de LUKS pour chiffrer vos disques. Le déchiffrement est automatisé au boot grâce à la présence d’une clé USB, garantissant ainsi qu’aucune donnée sensible ne soit accessible sans ce token de déchiffrement. Il fait parti d’un ensemble de cinq articles pour un système d’information de voyage.

Introduction

Le besoin d’un NAS chiffré pour protéger vos données est d’autant plus critique lorsque l’on utilise du matériel frugal comme le Raspberry Pi 3. Ce guide vous explique comment :

• Utiliser ZFS pour la gestion des disques (gestion de redondance, snapshots, et optimisation des E/S).
• Configurer LUKS pour le chiffrement des trois disques durs USB.
• Automatiser le déchiffrement au boot via la détection d’une clé USB contenant la clé secrète.
• Rester dans une approche sans interface web, pour un système léger et facilement scriptable.

Ce guide est idéal pour les sysadmins en quête d’une solution open source robuste, sécurisée et entièrement contrôlée en ligne de commande.

Prérequis

Matériel

• Raspberry Pi 3 (idéalement avec Raspberry Pi OS 64-bit ou une distribution adaptée)
• Carte microSD (16 Go ou plus pour le système)
• 3 disques durs USB (préférablement avec alimentation externe pour éviter des problèmes d’alimentation)
• Clé USB contenant la clé de déchiffrement

Logiciel

• Système d’exploitation basé sur Debian/Raspbian (Raspberry Pi OS)
• Paquets à installer :
  • cryptsetup
  • zfs-dkms
  • zfsutils-linux
  • Outils utilitaires en CLI : udev, systemd, ssh, parted, lsblk

1. Étapes du déploiement

1.1. Installation des paquets nécessaires

Commencez par mettre à jour la liste de vos paquets et installer les outils requis :

sudo apt update
sudo apt install -y cryptsetup zfsutils-linux zfs-dkms

1.2. Génération de la clé de déchiffrement

Générez une clé sécurisée, stockée temporairement dans /root avant d’être copiée sur la clé USB.

sudo dd if=/dev/random of=/root/.naskey bs=1024 count=4
sudo chmod 600 /root/.naskey

Ensuite, montez la clé USB (si elle n’est pas montée automatiquement) et copiez-y la clé :

# Monter la clé USB manuellement si besoin (exemple : /dev/sda1)
sudo mkdir -p /media/usbkey
sudo mount /dev/sda1 /media/usbkey

# Copier la clé sur la clé USB
sudo cp /root/.naskey /media/usbkey/.naskey

1.3. Chiffrement des disques avec LUKS

Pour chaque disque dur USB (supposons qu’ils apparaissent comme /dev/sdb, /dev/sdc, et /dev/sdd), procédez au chiffrement avec LUKS :

# Remplacer /dev/sdX par /dev/sdb, /dev/sdc, /dev/sdd respectivement
sudo cryptsetup luksFormat /dev/sdX --key-file /root/.naskey
sudo cryptsetup luksOpen /dev/sdX sdX_crypt --key-file /root/.naskey

Important : Répétez ces commandes pour chaque disque. Vous obtiendrez ainsi des devices mappés sous /dev/mapper/sdb_crypt, /dev/mapper/sdc_crypt, et /dev/mapper/sdd_crypt.

1.4. Création du pool ZFS

Une fois vos disques déchiffrés et mappés, créez le pool ZFS en utilisant une configuration de type RAID-Z :

sudo zpool create naspool raidz /dev/mapper/sdb_crypt /dev/mapper/sdc_crypt /dev/mapper/sdd_crypt

Le pool naspool est maintenant prêt à recevoir des datasets et à bénéficier des fonctionnalités avancées de ZFS telles que la compression et les snapshots.

1.5. Création des datasets ZFS

Créez un dataset principal pour stocker vos données et activez la compression pour optimiser l’espace disque :

sudo zfs create naspool/data
sudo zfs set compression=lz4 naspool/data

Vous pouvez ajouter d’autres datasets selon vos besoins (par exemple pour les sauvegardes, les partages, etc.).

1.6. Configuration du montage au boot et déchiffrement automatique

Pour automatiser le montage, nous allons utiliser une règle udev et un script personnalisé.

Création d’une règle udev

Créez une règle udev qui surveillera la connexion d’un périphérique de label spécifique (ici, nous utilisons le label NASKEY pour identifier la clé USB).

sudo vim /etc/udev/rules.d/99-decrypt.rules

Ajoutez-y le contenu suivant :

ACTION=="add", SUBSYSTEM=="block", KERNEL=="sd[a-z][0-9]", ENV{ID_FS_LABEL}=="NASKEY", RUN+="/usr/local/bin/decrypt-disks.sh"

Assurez-vous que la clé USB utilisée possède bien le label NASKEY. Pour le définir, vous pouvez utiliser la commande e2label (pour un système de fichiers ext2/3/4) ou l’outil correspondant pour votre système.

Création du script de déchiffrement automatique

Créez le script /usr/local/bin/decrypt-disks.sh qui va être exécuté lors de l’insertion de la clé USB :

sudo nano /usr/local/bin/decrypt-disks.sh

Ajoutez le script suivant :

#!/bin/bash
# Chemin vers la clé de déchiffrement sur la clé USB
KEY="/media/NASKEY/.naskey"

# Pour chaque disque (ici: /dev/sdb, /dev/sdc, /dev/sdd), déverrouille LUKS
for dev in /dev/sd[bcd]; do
  # On détermine un nom simple pour le mapping
  mapper_name="$(basename ${dev})_crypt"
  # Déverrouillage du disque
  /sbin/cryptsetup luksOpen "$dev" "$mapper_name" --key-file "$KEY"
done

# Importation automatique de tous les pools ZFS disponibles
/usr/sbin/zpool import -a

Rendez le script exécutable :

sudo chmod +x /usr/local/bin/decrypt-disks.sh

Vous pouvez également créer un service systemd complémentaire pour vérifier la présence de la clé USB et déclencher un verrouillage si celle-ci est absente après le boot.

1.7. Tests et vérifications

Après la configuration, procédez aux tests pour vous assurer que tout fonctionne correctement :

1. Redémarrage Test :
   • Éteignez le Raspberry Pi.
   • Insérez la clé USB (vérifiez qu’elle est bien montée avec le label NASKEY).
   • Redémarrez le Raspberry Pi.
2. Vérification des disques déchiffrés :
   • Exécutez lsblk pour confirmer la présence des devices /dev/mapper/sd[bcd]_crypt.
3. Vérification du pool ZFS :
   • Utilisez sudo zpool status pour vérifier que le pool naspool est correctement importé et actif.
4. Test d’accès aux données :
   • Montez le dataset ou accédez-y pour vous assurer que tout fonctionne en lecture/écriture via SSH.

2. Optimisations complémentaires

Pour un Raspberry Pi 3 qui dispose de ressources limitées, quelques optimisations s’imposent :

• Réduction de l’utilisation de la RAM par ZFS (limitation de l’ARC) :

  echo "options zfs zfs_arc_max=536870912" | sudo tee /etc/modprobe.d/zfs.conf
  

• Optimisation des accès disque :
  Désactivez la mise à jour de l’atime pour alléger les E/S :

  sudo zfs set atime=off naspool/data
  

• Contrôle d’alimentation USB : Si vous utilisez un hub USB alimenté, assurez-vous qu’il délivre une alimentation suffisante pour éviter des déconnexions intempestives.

Conclusion

Ce guide vous a présenté comment déployer un NAS chiffré full open source sur un Raspberry Pi 3 en utilisant ZFS pour la gestion de vos disques et LUKS pour le chiffrement. Le système est pensé pour être entièrement administrable via ssh, sans interface graphique, afin de maximiser la flexibilité et la légèreté. Grâce à l’utilisation d’une clé USB pour le déchiffrement automatique au démarrage, vous assurez une sécurité supplémentaire : sans la clé, aucun accès aux données n’est possible.

Cette solution s’adresse aux administrateurs système souhaitant mettre en place un NAS résilient, sécurisé et transportable, tout en restant dans une approche de scripts et commandes en ligne.

Notre série sur un SI de voyage hautement sécurisé

Si vous ne les avez pas encore lu, retrouvez notre série d’articles sur la conception un Système d’Information transportable :

• Introduction : Faire un SI de voyage hautement sécurisé
• Un cluster Kubernetes de voyage
• Une borne wifi en mode Zero-Trust
• Un réseau wifi full mesh, le plus sécurisé possible
• Installation d’un cluster K3S hors ligne