Volumi criptati LUKS - Creazione e uso con cryptmount

Attenzione. Questa guida è da considerarsi abbandonata, per via del tempo trascorso dall'ultima verifica. Potrà essere resa obsoleta, previa segnalazione sul forum, se nessuno si propone per l'adozione.

Versioni Compatibili Debian 5 "lenny" Debian 6 "squeeze" Debian 7 "wheezy" Debian 8 "jessie"

Introduzione

Generalmente si tende a pensare che un accesso indesiderato ai nostri dati possa avvenire da un'intrusione da rete. Certamente questo è lo scenario tipico, ma non bisognerebbe scordare che il più delle volte per accedere a un dato contenuto su un certo supporto, basta avere accesso "fisico" al supporto stesso.
Questo è molto più importante oggi giorno di quanto non fosse fino a pochi anni fa a causa della diffusione di sistemi di memorizzazione di massa portabili, estremamente comodi e che ci stiamo abituando ad avere sempre con noi, nello zaino, in una tasca o marsupio.
Altro scenario interessante è quello nel quale i dati in questione sono contenuti in un computer acceso e connesso alla rete, ma sono dati che ci interessa avere a disposizione esclusiva del nostro utente, e quindi se un'intrusione ci deve proprio essere è utile rendere all'intruso la vita molto dura nell'ottenimento di quei dati sensibili.
In questa guida sono contenuti i passi necessari per cifrare una partizione o una periferica (rimovibile o meno) o creare un file che useremo come loop device cifrata (con il vantaggio di essere estremamente trasportabile e archiviabile). Questo sarà mostrato nello scenario più semplice, quello con accesso ai file da parte di un singolo utente. La tecnologia usata però è quella nota col nome di LUKS (Linux Unified Keys Setup) che consente l'utilizzo della crittografia in scenari molto più articolati, con una base di compatibilità che andrà sempre crescendo in tutto il mondo Linux (questo è uno degli obiettivi del progetto). È bene fare le cose fin da subito compatibili con uno standard che sarà sempre più importante oltre che ricco di potenzialità, soprattutto riflettendo sull'accresciuta rilevanza data alla riservatezza dei propri dati digitali, anche dagli utenti semplici.

Prerequisiti e preparazione del sistema

Kernel precompilato Debian

Hardware A livello hardware la cifratura con algoritmo AES è molto leggera quindi può essere eseguita anche su macchine molto datate, o piccoli sistemi embedded.

La prima cosa da controllare prima di cimentarsi nella criptazione è l'abilitazione del kernel a usare l'algoritmo AES.
In un terminale eseguiamo:

$ cat /proc/crypto

e dovremmo ottenere (in base anche ai moduli caricati) qualcosa tipo:

name         : aes
driver       : aes-asm
module       : aes_i586
priority     : 200
refcnt       : 1
selftest     : passed
type         : cipher
blocksize    : 16
min keysize  : 16
max keysize  : 32

name         : aes
driver       : aes-generic
module       : aes_generic
priority     : 100
refcnt       : 1
selftest     : passed
type         : cipher
blocksize    : 16
min keysize  : 16
max keysize  : 32
[...]
name         : md5
driver       : md5-generic
module       : kernel
priority     : 0
refcnt       : 1
selftest     : passed
type         : shash
blocksize    : 64
digestsize   : 16

Ovviamente a noi interessano le sezioni che iniziano con name  : aes. Se non dovessero comparire dobbiamo controllare che i moduli responsabili dell'aes siano caricati e ottenere un output simile a questo:

$ lsmod |grep aes
aes_i586               16608  0 
aes_generic            37066  1 aes_i586

(o aes-x86_64 in caso di architettura per kernel amd64).
AES ci serve per la cifratura, ora dobbiamo pensare all'hash. Per l'hash serve l'algoritmo sha256 (ovviamente potremmo voler usare lo sha512, per cui basterebbe cambiare il 256 in 512 in ogni occorrenza). È precompilato nel kernel Debian, ma non è detto che sia caricato (nel /proc/crypto, soprariportato, non è infatti presente) quindi carichiamolo:

# modprobe sha256_generic

Nel file /proc/crypto si dovrebbero essere aggiunte le seguenti righe:

name         : sha256
driver       : sha256-generic
module       : sha256_generic
priority     : 0
refcnt       : 3
selftest     : passed
type         : shash
blocksize    : 64
digestsize   : 32
name         : sha256
driver       : sha256-generic
module       : sha256_generic
priority     : 0
refcnt       : 1
type         : digest
blocksize    : 64
digestsize   : 32

Infine l'ultimo modulo da caricare nel kernel è dm-crypt, la cui assenza impedisce a cryptmount di completare le operazioni richieste.

# modprobe dm-crypt

Nota: bisogna caricare i moduli?

Questi moduli richiesti sono stati indicati per esteso per capire un po' meglio cosa usiamo e perché. Non è necessario caricare manualmente alcun modulo, però, perché cryptmount dà istruzioni a chi di competenza per caricare tutti quelli necessario in modo trasparente all'utente.

Kernel personalizzato

Se non usiamo un kernel precompilato Debian, dobbiamo controllare che l'algoritmo di cifratura sia stato compilato: dal menu "Linux Kernel Configuration" seguiamo la voce "Cryptographic options --->" e abilitiamo la voce:

AES cipher algorithms

o la strettamente legata:

AES cipher algorithms (i586)

Pacchetti necessari

Per ottenere cryptmount e cryptsetup servirà installare i relativi pacchetti con il comando:

# apt-get install cryptmount cryptsetup

questo installerà anche tutte le dipendenze necessarie. In particolare verranno installati i pacchetti e le librerie per implementare il sistema di mappatura dei dispositivi (device-mapper) per il kernel Linux tramite il modulo dm-crypt.
Sia cryptmount che cryptsetup si propongono come frontend per l'utente finale allo scopo di consentire l'uso del Device Mapper.

Preparazione del file o della periferica

Per la preparazione del file system (su file o su periferica a blocchi fisica) criptato secondo LUKS possiamo usare cryptmount se vogliamo caratteristiche base di quest'ultimo. Per avere accesso a un supporto completo di LUKS, come dice il manuale stesso di cryptmount, è necessario usare cryptsetup.

Cryptsetup

Per preparare un file di dimensione fissata (in base alla quantità e tipo di dati che vorremo salvare cifrati) usiamo il comando dd:

$ dd if=/dev/zero of=/home/nomeutente/immagine_cifrata ibs=1M count=10

per creare un file da poi usare di 10MB nella home dell'utente nomeutente (queste dimensioni ridottissime sono adatte a una prova o per pochi dati che possono essere anche spediti in modo sicuro come allegato a un messaggio di posta).

File ordinario montato in loop

Autentichiamoci come root e montiamo il file appena creato in loop. Prima di tutto impostiamo il file appena creato come una loop device (controllare la prima periferica loop libera con losetup -f):

# /sbin/losetup /dev/loop/0 /home/nomeutente/immagine_cifrata

Periferica a blocchi fisica

Per chi invece di cifrare un file montato in loop, deve cifrare una block device ordinaria, basta che sappia quale nome le abbia assegnato il kernel (con precisione, perché la procedura seguente cancellerà tutti i dati nella periferica).

Periferiche D'ora in poi chiameremo /dev/periferica la block device sulla quale scriveremo i dati cifrati, sia essa la periferica in loop del paragrafo precedente (/dev/loop/0) o una periferica ordinaria

Creiamo la partizione LUKS:

# cryptsetup --verify-passphrase --verbose --hash=sha256 --cipher=aes-cbc-essiv:sha256 --key-size=256 luksFormat /dev/periferica

WARNING!
========  ========
This will overwrite data on /dev/periferica irrevocably.

Are you sure? (Type uppercase yes):  

Come dice il messaggio bisogna rispondere con uno YES interamente maiuscolo.
Ci verrà di seguito chiesta una parola d'ordine e la sua conferma; mentre le digiteremo non vedremo nulla cambiare nel terminale:

Enter LUKS passphrase:
Verify passphrase:

Command successful.

Mappare e montare la partizione criptata

A questo punto dobbiamo dare istruzioni al device mapper di mappare la periferica LUKS appena creata in una block device virtuale sulla quale scrivere i nostri dati in chiaro (e poi essi saranno scritti cifrati su /dev/periferica):

# cryptsetup luksOpen /dev/periferica criptata

Questo creerà la periferica /dev/mapper/criptata, sulla quale noi andremo a creare il file system che più ci interessa (su periferiche piccole come quella in esempio non conviene usare un file system con indicizzazione come reiserfs o ext3, bensì un più semplice ext2 o una FAT):

# mkfs -t ext2 /dev/mapper/criptata

Non ci rimane che montarla in una cartella di prova per verificare che sia tutto corretto (funzionamento, dimensioni desiderate ecc.):

# mount -t auto /dev/mapper/criptata /mnt/prova

Rimozione della periferica criptata

Per rimuovere la periferica cifrata bisogna innanzi tutto smontarla, poi bisogna dire a cryptsetup di chiudere la periferica (il che automaticamente eliminerà il nodo creato dal device mapper):

# umount /mnt/prova
# /sbin/cryptsetup luksClose criptata

Rimozione di una loop device

Nel caso in cui la nostra periferica sia un file montato in loop, è consigliabile eliminare il collegamento che il nostro file immagine ha con la periferica loop cui l'abbiamo associato; questo ci permetterà di spostare o eliminare il file senza creare malfunzionamenti nelle periferiche di loop, così come ci consentirà di aprire nuove periferiche in loop ripartendo dalla numero 0:

# /sbin/losetup -d /dev/loop0

Cryptmount

Il passo di base da compiere con cryptmount è modificare il file di configurazione /etc/cryptmount/cmtab. Per questa operazione e per usare l'opzione --generate-key è necessario avere i privilegi dell'utente root.
La struttura del file è costituita da un nome (utilizzato dal device mapper per identificare un dispositivo) seguito da un blocco racchiuso da parentesi graffe che contiene coppie chiave/valore. È possibile inserire più nomi a cui assegnare il proprio blocco specifico. Ad esempio:

nome1 {
       chiave=valore
       chiave=valore
       ...
}

nome2 {
       chiave=valore
       chiave=valore
       ...
}
...
...

nome

utilizzato dal sistema di mappatura dei dispositivi per identificare univocamente un dispositivo (sia esso un file o una partizione). Può essere scelto liberamente.

dev

la partizione da cifrare o il file che conterrà il file system cifrato. Quest'ultimo caso è utile se, ad esempio, si vuole avere un file system cifrato (con all'interno file e directory) senza avere una partizione separata. Questo campo è obbligatorio.

fstype

il tipo di file system (ext2, ext3, ext4, etc.) utilizzato per montare il dispositivo cifrato. Questo campo è obbligatorio.

keyfile

il file che conterrà la chiave per decifrare il file system cifrato. Nel caso si scelga "luks" come valore per "keyformat", è fortemente consigliato utilizzare lo stesso valore scelto per "dev" oppure lasciare questo campo senza un valore. Questo campo è obbligatorio.

keyformat

il tipo di sistema utilizzato per interagire con la chiave contenuta in "keyfile". In questa guida si farà riferimento al valore "luks" mentre, se non specificato, verrà assunto il valore di default "builtin".
Per visualizzare tutti i formati disponibili è possibile eseguire il comando cryptmount -k .
Il formato builtin salva la chiave in un file separato (da specificare nel campo keyfile), con "luks" invece la chiave è conservata all'inizio del file system.

Nota Questa assunzione fatta da luks (che le chiavi, che possono essere multiple, risiedano all'inizio del file system) impedisce l'uso di luks con la possibilità di cryptmount di creare più file system criptati all'interno della stessa periferica.

dir

il mountpoint che specifica il percorso assoluto della directory in cui verrà montato il file system cifrato. Crearlo se non dovesse esistere oppure, se già presente, assicurarsi che non contenga alcun file/directory al suo interno e che sia stato creato dallo stesso utente con cui si vuole in seguito montare il file system cifrato. In pratica un mountpoint creato da root impedirà il mount ad un utente normale (a meno di cambiare i permessi del punto di mount).

cipher

l'algoritmo di cifratura utilizzato per ottenere il file system cifrato. La scelta varia in base alle proprie necessità, alla capacitò di calcolo della macchina e, ovviamente, alla disponibilità dei moduli di cifratura compilati per il proprio kernel; una lista è visibile nella directory /proc/crypto .

Nei prossimi paragrafi verranno elencati i passi per creare un file system criptato con LUKS per un'intera partizione oppure per un file system criptato contenuto in un singolo file.

File system criptato su partizione

Se si ha a disposizione una partizione su cui creare un file system criptato, è possibile utilizzarla in modo molto semplice per contenere file e directory cifrate.
Tutti i file presenti sulla partizione, se non salvati, verranno persi.

Creazione di una voce in cmtab

La creazione di una voce nel file /etc/cryptmount/cmtab segue la sintassi per chiave/valore scritta in precedenza. Qui verrà utilizzata questa configurazione da adattare alle proprie necessità:

partizione_criptata {
        keyformat=luks
        dev=/dev/sda5
        keyfile=/dev/sda5
        dir=/home/pippo/crypt
        fstype=ext4
        mountoptions=defaults
        cipher=aes
}

in particolare:

partizione_criptata

è il nome univoco assegnato che verrà utilizzato da cryptmount per identificare il file system criptato.

dev=/dev/sda5

è il device associato alla partizione che si intende criptare. Va modificato in base alla partizione scelta.

dir=/home/pippo/crypt

il punto di mount, ossia la directory "crypt" all'interno della home dell'utente "pippo". Questa directory deve esistere, in caso contrario deve essere creata dal normale utente (quindi non root) con:

$ mkdir /home/pippo/crypt

Chiaramente si può scegliere liberamente il nome e il path della directory, purché l'utente ne possegga i permessi di scrittura, e il nome ("pippo" va sostituito con quello del proprio utente).

Creazione della chiave

La creazione della chiave viene effettuata tramite il comando "cryptmount --generate-key" eseguito come utente root. Questo comando accetta due parametri: la lunghezza della chiave (espressa in byte) e il nome assegnato in cmatb alla partizione cifrata. Ad esempio con:

# cryptmount --generate-key 32 partizione_criptata

Viene generata una chiave di 32 byte (256 bit) per "partizione_criptata".
La lunghezza della chiave dipende dall'algoritmo di cifratura scelto (in questo caso "aes") tramite il valore "cipher" in "cmtab".
Consultare il file /proc/crypto per ottenere la lunghezza minima o massima consentita (valori "min keysize" e "max keysize") per un certo algoritmo. Ad esempio, per l'algoritmo "xts" è permessa una lunghezza massima di 64 byte (512 bit).

Durante questa fase verrà chiesto:

1. di digitare la parole 'yes" per confermare l'operazione. Questo, come riporta anche il messaggio che apparirà sullo schermo, distruggerà probabilmente tutti i dati presenti sulla partizione scelta. Se si è pensato ad un backup, questa è l'ultima occasione per farlo.
2. di inserire per due volte una password a scelta.

Creazione del file system

L'operazione finale consiste nella creazione del file system vero e proprio e nella sua mappatura.
Diciamo a cryptmount di preparare il volume per la creazione del file system:

# cryptmount --prepare partizione_criptata

Diamo il comando di creazione del file system:

# mke2fs -t ext4 /dev/mapper/partizione_criptata

Nota Si noti che la periferica su cui scrivere in chiaro e che è poi mappata, attraverso il cifratore, su quella fisica, è in /dev/mapper esattamente come quando si fanno le cose manualmente con cryptsetup, che altro non è che uno strumento più a basso livello per l'interazione con dm_crypt.

Chiudiamo la fase di preparazione:

# cryptmount --release partizione_criptata

File system criptato su file

Nel caso non si abbia una partizione dedicata (o non si voglia crearne una), la scelta di un file come "contenitore" del file system criptato è una soluzione decisamente comoda. Questo approccio ha il vantaggio, oltre a quello di essere semplice da implementare e da gestire, di permettere un'agevole copia del file stesso per esigenze di backup.

Creazione di una voce in cmtab

Analogamente a quanto visto per una partizione, è necessario creare una voce nel file /etc/cryptmount/cmtab. Ad esempio:

file_criptato {
        keyformat=luks
        dev=/home/pippo/file_criptato.img
        keyfile=/home/pippo/file_criptato.img
        dir=/home/pippo/cryptfile
        fstype=ext4
        mountoptions=defaults
        cipher=aes
}

in particolare:

file_criptato

è il nome univoco assegnato che verrà utilizzato da cryptmount per identificare il file system criptato.

dev=/home/pippo/file_criptato.img

è il nome del file che conterrà il file system criptato. Può trovarsi in punto qualunque del file system, purché l'utente vi abbia accesso in scrittura.
Il nome qui scelto ("file_criptato.img") è puramente indicativo.

dir=/home/pippo/cryptfile

il punto di mount, ossia la directory "cryptfile" all'interno della home dell'utente "pippo". Valgono le stesse considerazioni scritte per un file system criptato su partizione.

Creazione del file

A differenza di quanto avveniva per la partizione, in questo caso il file deve essere effettivamente creato con:

$ dd if=/dev/zero of=/home/pippo/file_criptato.img bs=1M count=512

Per un file delle dimensioni di circa 512MB.
Notare che il comando va impartito come utente normale.

Creazione della chiave

La creazione della chiave è identica a quella già vista per una partizione e valgono ancora le considerazioni precedentemente illustrate, cambia solo il nome identificativo:

# cryptmount --generate-key 32 file_criptato

Creazione del file system

Anche quest'operazione è in tutto e per tutto identica a quanto visto in precedenza:

# cryptmount --prepare file_criptato
# mke2fs -t ext4 /dev/mapper/file_criptato
# cryptmount --release file_criptato

Uso del volume cifrato

Il grande vantaggio rispetto a cryptsetup è nell'uso quotidiano. Infatti, non è più richiesta l'autenticazione come super utente per montare o smontare il volume criptato (né che sia un volume fisico o un file in loop). Ogni utente può dare:

cryptmount -m criptata

o anche semplicemente:

cryptmount criptata

inserire la parola d'ordine, e usare il file system appena montato. Tutta la sicurezza è, a parte gli ottimi algoritmi di hash e cifratura usati che scongiurano, ragionevolmente, attacchi di forza bruta, nella parola d'accesso.
Uno schema di funzionamento diverso, quello con la chiave conservata altrove è interessante perché separa chiave e dati, lasciando alla memoria dell'utente solo il terzo ingrediente. Questo non è però nello standard luks, quindi non relativo a questa guida.

Disclaimer Se LUKS prevede l'uso di chiavi esterne, un minimo di studio lo rivelerà e in caso affermativo tornerò ad aggiornare questa guida.

Per smontare la periferica criptata basta, essendo autenticati come l'utente che ha montato il volume o super user:

cryptmount -u criptata

Gestione manuale

Per una gestione manuale dei volumi, bisogna usare i comandi losetup, crytpsetup e mount.
Uno script è forse il modo più indicato per avere un controllo estremamente preciso delle operazioni svolte in allocazione della risorsa criptata e seguente chiusura; due esempi in tal direzione sono presenti nella guida LUKS gestione manuale dei volumi: cryptsetup.

---

Guida scritta da: GipPasso	Debianized 40%
Estesa da: S3v 15:49, 3 mag 2016 (CEST) (cryptmount) (CEST)
Verificata da: HAL 9000 18:46, 20 giu 2014 (CEST)
Verificare ed estendere la guida | Cos'è una guida Debianized