LUKS : Chiffrer vos volumes Linux de la bonne façon

Votre disque est volé. Quelqu'un retire le HDD du serveur. Sans chiffrement, vos données sont lisibles en quelques secondes avec n'importe quel autre PC. LUKS est la réponse standard sur Linux — natif, well-tested, intégré dans cryptsetup. Ce guide ne vous montre pas juste comment activer LUKS. Il vous montre comment le faire correctement : backup des en-têtes, gestion des clés, intégration avec LVM, déverrouillage automatique via SSH. Parce que chiffrer est bien, mais chiffrer et se locker dehors, c'est pire.

• Linux : Debian, Ubuntu, RHEL, Rocky
• Paquet cryptsetup installé (apt install cryptsetup ou yum install cryptsetup)
• Un disque ou une partition libre pour tester (ne jamais tester sur un volume en production sans backup)
• Connaissance de base de LVM (vous pouvez chiffrer un LV)
• Accès root

LUKS chiffre une partition entière. Tout ce qui est écrit dessus est automatiquement chiffré en AES-256. Pour monter la partition, vous devez d'abord la déverrouiller avec une clé — mot de passe, fichier clé, ou les deux. Une fois déverrouillée, elle apparaît comme un périphérique normal dans /dev/mapper/.

Disque physique /dev/sdb1
    → LUKS (en-tête chiffré + données chiffrées)
        → cryptsetup open → /dev/mapper/mon-volume
            → mount → /mnt/data

1. Formater la partition en LUKS

# ATTENTION : cette commande efface tout sur /dev/sdb1
sudo cryptsetup luksFormat --cipher aes-xts-plain64 --key-size 512 --hash sha512 /dev/sdb1

Vous serez invité à entrer une passphrase. Choisissez-en une forte — 20+ caractères, pas un mot du dictionnaire.

2. Déverrouiller la partition

sudo cryptsetup open --type luks /dev/sdb1 mon-volume
# Entrez votre passphrase

Le périphérique apparaît maintenant sur /dev/mapper/mon-volume.

3. Formater et monter

sudo mkfs.ext4 /dev/mapper/mon-volume
sudo mkdir -p /mnt/data
sudo mount /dev/mapper/mon-volume /mnt/data

4. Rendre permanent dans fstab + crypttab

# Récupérer l'UUID de la partition LUKS
sudo blkid /dev/sdb1
# UUID="xxxx-xxxx-xxxx-xxxx" TYPE="crypto_LUKS"

# /etc/crypttab — déverrouillage au boot
# Format : nom    source-device    clé    options
echo "mon-volume    UUID=xxxx-xxxx-xxxx-xxxx    none    luks2" | sudo tee -a /etc/crypttab

# /etc/fstab — montage après déverrouillage
echo "/dev/mapper/mon-volume    /mnt/data    ext4    defaults    0    2" | sudo tee -a /etc/fstab

En production, la bonne architecture c'est : partition → LUKS → LVM. Vous chiffrez en dehors, vous gérez les volumes en dedans. Vous pouvez agrandir des LV sans toucher au chiffrement.

/dev/sdb1 (partition physique)
    → cryptsetup luksFormat → LUKS
        → cryptsetup open → /dev/mapper/sdb1-crypt
            → pvcreate → PV
                → vgcreate → VG "encrypted-pool"
                    → lvcreate → LV "appdata"  → /mnt/appdata
                    → lvcreate → LV "logs"     → /var/log

# Après avoir ouvert le LUKS (étape 2 ci-dessus) :
sudo pvcreate /dev/mapper/mon-volume
sudo vgcreate encrypted-pool /dev/mapper/mon-volume
sudo lvcreate -L 40G -n appdata encrypted-pool
sudo lvcreate -L 10G -n logs encrypted-pool

sudo mkfs.ext4 /dev/encrypted-pool/appdata
sudo mkfs.ext4 /dev/encrypted-pool/logs

sudo mount /dev/encrypted-pool/appdata /mnt/appdata
sudo mount /dev/encrypted-pool/logs /var/log

LUKS supporte jusqu'à 32 clés simultanées. Vous pouvez avoir une passphrase pour l'humain et un fichier clé pour l'automatisation.

Ajouter une clé

# Ajouter une deuxième passphrase (backup)
sudo cryptsetup luksAddKey /dev/sdb1

# Ajouter un fichier clé
sudo dd if=/dev/urandom of=/root/.luks-keyfile bs=512 count=1
sudo chmod 600 /root/.luks-keyfile
sudo cryptsetup luksAddKey /dev/sdb1 /root/.luks-keyfile

Voir les slots de clé utilisés

sudo cryptsetup luksDump /dev/sdb1 | head -30

LUKS header information for /dev/sdb1
Version:        2
UUID:           xxxx-xxxx-xxxx-xxxx
Device size:    100.0 GB
Key Slots:
 0: active
    Iterations: 650000
    Key material offset: 32
    AF stripes: 4000
 1: active
    Iterations: 580000
    Key material offset: 258048

Supprimer une clé

# Supprimer le slot 1 (fichier clé) — attention, irréversible
sudo cryptsetup luksKillSlot /dev/sdb1 1

L'en-tête LUKS contient toutes les métadonnées de chiffrement. S'il est corrompu, vous ne pouvez plus déverrouiller — même avec la bonne clé. Vous devez le sauvegarder régulièrement.

# Backup de l'en-tête
sudo cryptsetup luksHeaderBackup /dev/sdb1 --header-backup-file /var/backups/luks-header-sdb1.bin

# Vérifier la taille (doit être autour de 16 Mo pour LUKS2)
ls -lh /var/backups/luks-header-sdb1.bin

# Cette sauvegarde elle-même doit être sécurisée — elle ne contient pas les données,
# mais elle permet de restaurer l'en-tête si le disque est corrompu

# Script de backup automatique des en-têtes
#!/usr/bin/env bash
set -euo pipefail

readonly BACKUP_DIR="/var/backups/luks-headers"
readonly TIMESTAMP=$(date '+%Y%m%d_%H%M%S')
readonly LOG="/var/log/luks-backup.log"

log()   { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [INFO]  $*" | tee -a "$LOG"; }
error() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR] $*" | tee -a "$LOG" >&2; }

# Liste des périphériques LUKS à sauvegarder
declare -a LUKS_DEVICES=("/dev/sdb1" "/dev/sdc1")

main() {
    mkdir -p "$BACKUP_DIR"

    for dev in "${LUKS_DEVICES[@]}"; do
        local name
        name=$(basename "$dev")
        local backup_file="${BACKUP_DIR}/${name}_${TIMESTAMP}.bin"

        log "Backup en-tête LUKS : $dev"
        if cryptsetup luksHeaderBackup "$dev" --header-backup-file "$backup_file"; then
            log "OK : $backup_file"
        else
            error "Échec : $dev"
        fi
    done

    # Nettoyage — garder les 10 derniers backups par périphérique
    for dev in "${LUKS_DEVICES[@]}"; do
        local name
        name=$(basename "$dev")
        find "$BACKUP_DIR" -name "${name}_*.bin" | sort | head -n -10 | xargs -r rm
    done

    log "Backup en-têtes terminé"
}

main "$@"

# Si l'en-tête est corrompu, restaurer depuis le backup
sudo cryptsetup luksHeaderRestore /dev/sdb1 --header-backup-file /var/backups/luks-headers/sdb1_20260201_020000.bin

En production, vous ne voulez pas entrer une passphrase à chaque reboot. Utilisez un fichier clé stocké sur une partition séparée (non chiffrée, mais avec des permissions strictes).

# Générer le fichier clé
sudo dd if=/dev/urandom of=/boot/luks-keyfile bs=512 count=1
sudo chmod 600 /boot/luks-keyfile

# Ajouter cette clé au volume LUKS
sudo cryptsetup luksAddKey /dev/sdb1 /boot/luks-keyfile

# Dans /etc/crypttab, pointer vers le fichier clé
# mon-volume    UUID=xxxx    /boot/luks-keyfile    luks2

Note de sécurité : le fichier clé sur /boot est accessible si quelqu'un a un accès physique au serveur. C'est un bon compromis pour un datacenter sécurisé. Si vous êtes dans un environnement plus sensible, regardez du côté de Tang (network-bound encryption) ou de systemd-cryptenroll avec TPM2.

# État du périphérique chiffré
sudo cryptsetup status mon-volume

/dev/mapper/mon-volume is active and is in use.
  type:    LUKS2
  cipher:  aes-xts-plain64
  keysize: 512 bits
  key location: keyring
  device:  /dev/sdb1
  sector size: 512
  offset:  32768 sectors
  size:    204768 sectors
  mode:    read/write

# Vérifier que le périphérique est bien chiffré
sudo lsblk -o NAME,TYPE,SIZE,MOUNTPOINT,FSTYPE

Ne jamais oublier de sauvegarder l'en-tête LUKS — c'est la faute la plus coûteuse possible. Un en-tête corrompu sans backup, c'est des données définitivement perdues, peu importe la force de votre clé. Deuxième piège : stocker le fichier clé sur le même volume chiffré. C'est un deadlock garanti au reboot. Et enfin, ne pas tester la restauration — ni de l'en-tête, ni du déverrouillage depuis un fichier clé. Faites-le en dehors de la production, régulièrement.

Combinez LUKS avec LVM pour gérer les volumes ou avec LVM avancé pour les snapshots. Pour le partitionnement en amont, consultez partitionnement disque Linux.

LUKS vous donne du chiffrement transparent, natif, sans overhead significatif. Une partition chiffrée qui se comporte exactement comme une partition normale une fois déverrouillée. L'architecture recommandée reste LUKS + LVM — vous chiffrez en dehors, vous gérez en dedans. La prochaine étape ? Regardez systemd-cryptenroll pour du déverrouillage plus sécurisé (TPM2, FIDO2), ou intégrez LUKS à votre pipeline de backup rsync pour que vos copies offsite soient aussi chiffrées.