LUKS2 vs LUKS1: differenze, come verificarle e come convertire

In breve: LUKS2 è il formato su disco attuale per la cifratura dei dischi su Linux e quello predefinito in cryptsetup dalla versione 2.1. Rispetto a LUKS1 aggiunge un header di metadati JSON ridondante e con checksum, la derivazione della chiave memory-hard Argon2id al posto di PBKDF2, 32 keyslot invece di 8, token per lo sblocco con TPM2 e FIDO2 e una cifratura autenticata opzionale. Usa LUKS2, a meno che un vecchio GRUB non debba decifrare `/boot` da solo.

Entrambi i formati cifrano i dati allo stesso modo, di solito con AES-XTS. Ciò che cambia è l'header: come vengono conservate le chiavi, quanto è difficile forzare le passphrase e quali strumenti possono leggerlo. Questa guida tratta le differenze, come verificare quale hai e come convertire con `cryptsetup convert` senza perdere il disco. Se stai cifrando un server nuovo per uno stack self-hosting su un VPS piccolo, LUKS2 è il formato da scegliere.

LUKS2 vs LUKS1 a colpo d'occhio

Formato dell'header e keyslot

Un header LUKS1 è una struttura binaria fissa seguita da otto aree di keyslot. Se i primi settori del dispositivo vengono sovrascritti, per esempio da un `mkfs` sbagliato o da uno strumento di partizionamento, tutti i keyslot spariscono e i dati sono persi, a meno che tu non abbia un backup dell'header.

LUKS2 memorizza un header binario e un'area di metadati JSON, e conserva una seconda copia di entrambi. Ogni copia ha un checksum, quindi `cryptsetup` può rilevare la corruzione e ripiegare sull'altra copia. L'area JSON descrive keyslot, segmenti, digest e token, ed è questo che permette nuove funzionalità senza cambiare di nuovo il formato. La ridondanza comunque non sostituisce un backup dell'header: una sovrascrittura completa dei primi megabyte distrugge entrambe le copie.

Argon2id vs PBKDF2

La passphrase non viene mai usata direttamente come chiave. Una funzione di derivazione della chiave la «stira» in modo che ogni tentativo sia costoso. LUKS1 può usare solo PBKDF2, che costa poco su GPU e ASIC, quindi un attaccante con una copia dell'header può provare passphrase in parallelo ad alta velocità.

LUKS2 usa per impostazione predefinita Argon2id, che richiede una quantità configurabile di memoria per tentativo (fino a 1 GiB di default, limitata dalla RAM disponibile al momento della formattazione) ed è molto più costoso da parallelizzare. Una passphrase robusta resta la difesa principale, ma Argon2id aumenta notevolmente il costo di ogni tentativo.

Sui server piccoli tieni conto del costo in memoria. Un keyslot creato su una macchina con molta RAM può richiedere per lo sblocco più memoria di quanta un VPS da 1 GB, come il piano Wisp di NoctisNode, possa concedere dentro l'initramfs. Impostala esplicitamente con `--pbkdf-memory` (in KiB) quando formatti o aggiungi chiavi su una macchina grande destinate a una piccola.

# Inspect PBKDF parameters of each keyslot
cryptsetup luksDump /dev/vda3 | grep -A6 '^  [0-9]*: luks2'

# Re-derive keyslot 0 with Argon2id and 512 MiB memory cost
cryptsetup luksConvertKey /dev/vda3 --key-slot 0 \
  --pbkdf argon2id --pbkdf-memory 524288

Token, integrità e limiti di GRUB

I token sono oggetti JSON nell'header LUKS2 che indicano agli strumenti come ottenere una chiave automaticamente. `systemd-cryptenroll` li usa per legare un keyslot a un chip TPM2, a una chiave di sicurezza FIDO2 o a una smartcard PKCS#11, e Clevis li usa per lo sblocco legato alla rete con un server Tang. Niente di tutto questo esiste su LUKS1.

La modalità integrità (`cryptsetup luksFormat --integrity hmac-sha256`) combina la cifratura con dm-integrity, così i settori manomessi producono errori di lettura invece di dati alterati in silenzio. Costa spazio su disco e velocità di scrittura, richiede un wipe completo al momento della formattazione ed è ancora contrassegnata come sperimentale. La maggior parte dei server non la usa.

GRUB è il motivo principale per cui si incontra ancora LUKS1. Il GRUB upstream dalla 2.06 in poi può aprire LUKS2, ma solo keyslot che usano PBKDF2, perché il supporto ad Argon2 non fa parte del GRUB upstream. Se è GRUB stesso a dover decifrare un `/boot` cifrato, usa LUKS1 o un keyslot LUKS2 con `--pbkdf pbkdf2`. Gli installer di Debian e Ubuntu lasciano `/boot` non cifrato, quindi lo sblocco lo fanno kernel e initramfs e Argon2id funziona, anche per lo sblocco remoto via SSH.

Come verificare se un volume è LUKS1 o LUKS2

Su un sistema in esecuzione, come root, funziona uno qualsiasi di questi comandi. La riga `Version:` di `cryptsetup luksDump` è la risposta definitiva; il dump mostra anche keyslot, tipo di PBKDF e token.

# Find encrypted partitions (FSVER column shows 1 or 2)
lsblk -f

# Authoritative: header version
cryptsetup luksDump /dev/vda3 | grep -E '^Version'
# Version:        2

# Exit code 0 only if the device is LUKS2
cryptsetup isLuks --type luks2 /dev/vda3 && echo LUKS2

Convertire con cryptsetup convert

`cryptsetup convert` riscrive l'header sul posto; i dati cifrati non vengono toccati. Il dispositivo deve essere chiuso, quindi per un filesystem root lo esegui da un sistema rescue o live. Un errore o un'interruzione di corrente a metà conversione può rendere inutilizzabile l'header, ed è per questo che il backup non è facoltativo.

1. 01.Avvia un sistema rescue o live e assicurati che il dispositivo LUKS non sia aperto (`cryptsetup close` se necessario).
2. 02.Fai il backup dell'header con `cryptsetup luksHeaderBackup` e copia il file fuori dal server. Chiunque abbia questo file e una vecchia passphrase può sbloccare il disco, quindi conservalo cifrato.
3. 03.Converti LUKS1 in LUKS2 con `cryptsetup convert --type luks2`. I keyslot esistenti restano PBKDF2.
4. 04.Aggiorna ogni keyslot ad Argon2id con `cryptsetup luksConvertKey --pbkdf argon2id`, a meno che GRUB non debba leggerlo.
5. 05.Verifica che il dispositivo si apra, poi ricostruisci l'initramfs con `update-initramfs -u` e riavvia.
6. 06.Per tornare da LUKS2 a LUKS1, converti prima ogni keyslot in PBKDF2 e rimuovi token e funzionalità esclusive di LUKS2; altrimenti `cryptsetup convert --type luks1` si rifiuta.

# From a rescue system, device closed
cryptsetup luksHeaderBackup /dev/vda3 --header-backup-file /root/vda3-luks-header.img

cryptsetup convert --type luks2 /dev/vda3
cryptsetup luksConvertKey /dev/vda3 --key-slot 0 --pbkdf argon2id

cryptsetup open /dev/vda3 cryptroot && cryptsetup close cryptroot

# Emergency restore (overwrites the current header!)
# cryptsetup luksHeaderRestore /dev/vda3 --header-backup-file /root/vda3-luks-header.img

Note · Dopo un ripristino dell'header tornano a funzionare le passphrase valide al momento del backup, comprese quelle che hai rimosso in seguito. Elimina i vecchi backup dell'header quando cambi le passphrase. Conserva il backup attuale in un posto separato, per esempio nel repository descritto nella guida ai backup con restic.

FAQ