Volumi criptati LUKS - Creazione e uso con cryptmount: differenze tra le versioni

Vai alla navigazione Vai alla ricerca

Volumi criptati LUKS - Creazione e uso con cryptmount (visualizza wikitesto)

Versione delle 08:09, 29 set 2019

9 028 byte aggiunti ,  29 set 2019
m
→‎Creazione di una voce in cmtab
 
(66 versioni intermedie di 8 utenti non mostrate)
Riga 1: Riga 1:
Un accesso indesiderato ai nostri dati si tende a pensare che 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.
{{Versioni compatibili|Wheezy|Jessie|Stretch|Buster}}
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.
 
== 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.<br/>
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.<br/>
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.
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 [http://luks.endorphin.org/ 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 pensando a quanto la riservatezza dei propri dati digitali sia sempre più sentita come importante anche dagli utenti semplici.


Le tecniche mostrate in questa guida sono ancora "rozze" nel senso che richiedono per l'utente che le usa di autenticarsi come root, però possono costituire una base di partenza. {{Box|Disclaimer|Appena riuscirò a trovare la tecnica per evitare l'autenticazione come root, aggiornerò questa guida, rendendo la cifratura più adatta a sistemi multi-utente}}
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.<br/>
La distribuzione cui ci si riferisce è Etch, ma il discorso dovrebbe subire modifiche minime o nulle sia per Lenny che per Sid.
La tecnologia usata è quella nota col nome di [http://code.google.com/p/cryptsetup/ 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).<br/>
=='''Prerequisiti e preparazione del sistema'''==
È 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.
{{Box|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. I kernel precompilati di debian sono tutti già abilitati, quindi il controllo non dovrebbe essere necessario. In un terminale eseguiamo<pre>cat /proc/crypto</pre> e con il kernel 2.6.18 di etch dovremmo ottenere (in base anche ai moduli caricati) qualcosa tipo<pre>name        : sha256
driver      : sha256-generic
module      : sha256
priority    : 0
type        : digest
blocksize    : 64
digestsize  : 32


name        : aes
== Prerequisiti e preparazione del sistema ==
driver      : aes-generic
=== Moduli da caricare ===
module      : aes
Non c'è nulla da fare, è già tutto pronto. Se si volesse saperne di più, o se si sta utilizzando un [[kernel]] personalizzato, si raccomanda la lettura della [[#Moduli del kernel|sezione "Moduli del kernel"]] di questa guida.
priority    : 100
type        : cipher
blocksize    : 16
min keysize  : 16
max keysize  : 32


...</pre>
=== Pacchetti necessari ===
Ovviamente a noi interessa la sezione che inizia con '''name        : aes'''. Se non dovesse comparire dobbiamo controllare che il modulo '''aes''' sia caricato e ottenere un'output simile a questo: <pre>lsmod | grep aes
Per ottenere <code>cryptmount</code> e <code>cryptsetup</code> servirà installare i relativi pacchetti con [[privilegi di amministrazione]]:
aes                    28160  2</pre>.
<pre>
Se l'output dovesse essere vuoto dobbiamo caricare il modulo '''aes''' con l'usuale comando '''modprobe aes'''.
# apt install cryptmount cryptsetup
</pre>
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 <code>dm-crypt</code>.<br/>
Sia <code>cryptmount</code> che <code>cryptsetup</code> si propongono come frontend per l'utente finale allo scopo di consentire l'uso del Device Mapper.


Se non usaimo 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 <pre>AES cipher algorithms</pre> o la strettamente legata <pre>AES cipher algorithms (i586)</pre>
== 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 <code>cryptmount</code> se vogliamo caratteristiche base di quest'ultimo. Per avere accesso a un supporto completo di LUKS, come dice il manuale stesso di <code>cryptmount</code>, è necessario usare <code>cryptsetup</code>.


Sistemato il kernel passiamo all'installazione del software necessario:<pre>aptitude install cryptsetup</pre>che installerà tutte le dipendenze necessarie (piccole: l'installazione completa di tutte le sue dipendenze sta sotto i 2MB di spazio disco!).
== Cryptsetup ==
Per preparare un file di dimensione fissata (in base alla quantità e tipo di dati che vorremo salvare cifrati) usiamo il comando <code>dd</code>:<pre>$ dd if=/dev/zero of=/home/nomeutente/immagine_cifrata ibs=1M count=100</pre>
per creare un file da poi usare di 100 MB nella home dell'utente ''nomeutente''.


=='''Preparazione del file o della periferica'''==
=== File ordinario montato in loop ===
==='''Creare una loop device da un file'''===
Autentichiamoci come [[privilegi di amministrazione|root]] e montiamo il file appena creato in loop. Prima di tutto impostiamo il file appena creato come una [[loop device]]:
Per preparare un file di dimensione fissata (in base alla quantità e tipo di dati che vorremo salvare cifrati) usiamo il comando dd:<pre>dd if=/dev/zero of=/home/nomeutente/immagine_cifrata ibs=1M count=10</pre>per creare un file da poi usare di 10MB nella home di "nomeutente" (perdonate la poca fantasia).
<pre>
# losetup -f /home/nomeutente/immagine_cifrata
</pre>
Controllare poi quale è stata associata con (in questo caso <code>/dev/loop0</code>, la prima):
# losetup -a
'''/dev/loop0''': ... ('''/home/nomeutente/immagine_cifrata''')


Autentichiamoci come root e montiamo il file appena creato in loop. Prima di tutto impostiamo il file appena creato come una loop device (ammettendo che questa sia la prima periferica in loop del sistema):<pre>/sbin/losetup /dev/loop/0 /home/nomeutente/immagine_cifrata</pre>
=== Periferica a blocchi fisica ===
==='''Creare la partizione criptata'''===
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).
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 kenrel (con precisione, perché la procedura seguente cancellerà tutti i dati nella periferica).
{{Box|Periferiche|D'ora in poi chiameremo <code>/dev/periferica</code> la block device sulla quale scriveremo i dati cifrati, sia essa la periferica in loop del paragrafo precedente (<code>/dev/loop/0</code>) o una periferica ordinaria}}
{{Box|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, con parametri di default (la scelta raccomandata, salvo esigenze particolari):
Creiamo la partizione LUKS:<pre>cryptsetup --verify-passphrase --verbose --hash=sha256 --cipher=aes-cbc-essiv:sha256 --key-size=256 luksFormat /dev/periferica
<pre>
# cryptsetup --verify-passphrase --verbose luksFormat /dev/periferica


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


Are you sure? (Type uppercase yes): </pre>Come dice il messaggio bisogna rispondere con uno '''YES''' interamente maiuscolo.
Are you sure? (Type uppercase yes):
Ci verrà di seguito chiesta una parola d'ordine e la sua conferma; mentre le digiteremo non vedremo nulla cambiare nel terminale:<pre>Enter LUKS passphrase:
</pre>
Come dice il messaggio bisogna rispondere con uno <code>'''YES'''</code> interamente maiuscolo.<br/>
Ci verrà di seguito chiesta una parola d'ordine e la sua conferma; mentre le digiteremo non vedremo nulla cambiare nel terminale:
<pre>
Enter LUKS passphrase:
Verify passphrase:
Verify passphrase:
Command successful.</pre>
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):<pre>cryptsetup luksOpen /dev/periferica criptata</pre>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):<pre>mkfs -t ext2 /dev/mapper/criptata</pre>Non ci rimane che montarla in una cartella di prova per verificare che sia tutto corretto (funzionamento, dimensioni desiderate ecc.):<pre>mount -t auto /dev/mapper/criptata /mnt/prova</pre>


=='''Rimozione della periferca criptata'''==
Command successful.
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):<pre>umount /mnt/prova
</pre>
/sbin/cryptsetup luksClose criptata</pre>
 
==='''Rimozione di una loop device'''===
=== Mappare e montare la partizione criptata ===
Nel caso che 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:<pre>/sbin/losetup -d /dev/loop0</pre>
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 <code>/dev/periferica</code>):
<pre># cryptsetup open --type luks /dev/periferica criptata</pre>
Questo creerà la periferica <code>'''/dev/mapper/criptata'''</code>, 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):
<pre># mkfs -t ext2 /dev/mapper/criptata</pre>
Non ci rimane che montarla in una cartella di prova per verificare che sia tutto corretto (funzionamento, dimensioni desiderate ecc.):
<pre># mount /dev/mapper/criptata /mnt/prova</pre>
 
=== 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):
<pre>
# umount /mnt/prova
# cryptsetup close criptata
</pre>
 
=== 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:
<pre>
# losetup -d /dev/loop0
</pre>
 
== Cryptmount ==
Il passo di base da compiere con <code>cryptmount</code> è modificare il file di configurazione <code>/etc/cryptmount/cmtab</code>. Per questa operazione e per usare l'opzione <code>--generate-key</code> è necessario avere i [[privilegi di amministrazione]].<br/>
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:
<pre>
nome1 {
      chiave=valore
      chiave=valore
      ...
}
 
nome2 {
      chiave=valore
      chiave=valore
      ...
}
...
...
</pre>
;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".<br/>Per visualizzare tutti i formati disponibili è possibile eseguire il comando <code>cryptmount -k</code> .<br/>Il formato <code>builtin</code> salva la chiave in un file separato (da specificare nel campo <code>keyfile</code>), con "luks" invece la chiave è conservata all'inizio del file system. {{Box|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 <code>/proc/crypto</code> .
 
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.<br/>
<u>Tutti i file presenti sulla partizione, se non salvati, verranno persi</u>.
 
==== Creazione di una voce in <code>cmtab</code> ====
La creazione di una voce nel file <code>/etc/cryptmount/cmtab</code> segue la sintassi per chiave/valore scritta in precedenza. Qui verrà utilizzata questa configurazione da adattare alle proprie necessità:
<pre>
partizione_criptata {
        keyformat=luks
        dev=/dev/sda5
        keyfile=/dev/sda5
        dir=/home/pippo/crypt
        fstype=ext4
        mountoptions=nodev,nosuid
        cipher=aes
}
</pre>
in particolare:
;partizione_criptata:è il nome '''univoco''' assegnato che verrà utilizzato da <code>cryptmount</code> 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:<pre>$ mkdir /home/pippo/crypt</pre>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 <code>cmatb</code> alla partizione cifrata.
Ad esempio con:
<pre># cryptmount --generate-key 32 partizione_criptata</pre>
Viene generata una chiave di 32 byte (256 bit) per "partizione_criptata".<br/>
La lunghezza della chiave dipende dall'algoritmo di cifratura scelto (in questo caso "aes") tramite il valore "cipher" in "cmtab".<br/>
Consultare il file <code>/proc/crypto</code> 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).


=='''Automatizzazione dei passi necessari'''==
Durante questa fase verrà chiesto:
A questo punto dobbiamo solo creare uno script da eseguire come root, per fare tutte le operazioni di creazione e montaggio, o viceversa di smontaggio e rimozione automaticamente.
#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.
Di seguito sono riportati due script, uno per il caso di file montato ricorsivamente, l'altro per il caso di periferica ordinaria.
#di inserire per due volte una password a scelta.
In entrambi i casi il montaggio della periferica criptata avviene nella cartella "criptata" nella home dell'utente; è necessario quindi creare la cartella:<pre>mkdir /home/'''nomeutente'''/criptata</pre>
==='''Scritp per file immagine'''===
<pre>#Utilizzo di un file immagine come periferica criptata
#!/bin/bash


case $1 in
==== Creazione del file system ====
        monta)
L'operazione finale consiste nella creazione del file system vero e proprio e nella sua mappatura.<br/>
                if [ -f /home/'''nomeutente'''/immagine_cifrata ]; then
Diciamo a <code>cryptmount</code> di preparare il volume per la creazione del file system:
                    echo "Impostazione periferica ricorsiva (loop)."
<pre>
                    /sbin/losetup /dev/loop0 /home/'''nomeutente'''/immagine_cifrata
# cryptmount --prepare partizione_criptata
                fi
</pre>
Diamo il comando di creazione del file system:
<pre>
# mke2fs -t ext4 /dev/mapper/partizione_criptata
</pre>
{{Box|Nota|Si noti che la periferica su cui scrivere in chiaro e che è poi mappata, attraverso il cifratore, su quella fisica, è in <code>/dev/mapper</code> esattamente come quando si fanno le cose manualmente con cryptsetup, che altro non è che uno strumento più a basso livello per l'interazione con <code>dm_crypt</code>.}}
Chiudiamo la fase di preparazione:
<pre>
# cryptmount --release partizione_criptata
</pre>


                if [ $? = 0 ]; then
=== File system criptato su file ===
                    /sbin/cryptsetup luksOpen /dev/loop0 criptata
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.
                else
                    echo "Impostazione periferica ricorsiva non riuscita."
                fi


                if [ $? = 0 ]; then
==== Creazione di una voce in <code>cmtab</code> ====
                    mount /dev/mapper/criptata /home/'''nomeutente'''/criptata
Analogamente a quanto visto per una partizione, è necessario creare una voce nel file <code>/etc/cryptmount/cmtab</code>. Ad esempio:
                fi
<pre>
file_criptato {
        keyformat=luks
        dev=/home/pippo/file_criptato.img
        keyfile=/home/pippo/file_criptato.img
        dir=/home/pippo/cryptfile
        fstype=ext4
        mountoptions=nodev,nosuid,noexec
}
</pre>
in particolare:
;file_criptato:è il nome '''univoco''' assegnato che verrà utilizzato da <code>cryptmount</code> 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.<br/>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.


                if [ $? !=0 ]; then
==== Creazione del file ====
                    echo "Impossibile montare la periferica criptata."
A differenza di quanto avveniva per la partizione, in questo caso il file deve essere effettivamente creato con:
                    /sbin/cryptsetup luksClose criptata
<pre>
                    /sbin/losetup -d /dev/loop0
$ dd if=/dev/zero of=/home/pippo/file_criptato.img bs=1M count=512
                fi
</pre>
        ;;
Per un file delle dimensioni di circa 512MB.<br/>
        smonta)
Notare che il comando va impartito come '''utente normale'''.
                umount /dev/mapper/criptata
                echo "Smontaggio riuscito"


                if [ $? = 0 ]; then
==== Creazione della chiave ====
                    /sbin/cryptsetup luksClose criptata
La creazione della chiave è identica a quella già vista per una partizione e valgono ancora le considerazioni precedentemente illustrate, cambia solo il nome identificativo:
                else
<pre>
                    echo "Smontaggio non riuscito."
# cryptmount --generate-key 32 file_criptato
                fi
</pre>


                if [ $? = 0 ]; then /sbin/losetup -d /dev/loop0
==== Creazione del file system ====
if [ $? = 0 ]; then
Anche quest'operazione è in tutto e per tutto identica a quanto visto in precedenza:
    echo "Periferica criptata chiusa"
<pre>
    touch /home/'''nomeutente'''/criptata.img
# cryptmount --prepare file_criptato
else echo "Chiusura periferica criptata non riuscita"
# mke2fs -t ext4 /dev/mapper/file_criptato
        fi
# cryptmount --release file_criptato
fi
</pre>
        ;;
        *)
        echo "Usage: $1 {monta|smonta}" >&2
        exit 1
        ;;
esac</pre>
Nello script ho inserito il comando touch per impostare all'ora attuale le date di ultimo accesso e modifica del file criptata.img.
Ho ritenuto importante una modifica esplicita di queste informazioni del file, perché può risultare molto più comodo sapere quali file cifrati sono stati aprerti di recente, nel caso se ne vogliano fare delle copie di backup.
Se non si inserisce quella riga, programmi di backup (che spesso si appoggiano su librsync) non possono accorgersi che il file cifrato è stato cambiato o è stato aperto di recente e non lo considerano nel sincronizzare le varie copie.


==='''Scritp per periferica ordinaria'''===
== Uso del volume cifrato ==
In questo esempio viene usata la prima partizione di una scheda di memoria SD (/dev/mmcblk0p1 con lettore compatibile con il modulo sdhci).
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).
<pre>#!/bin/bash
Ogni utente può dare:
<pre>
$ cryptmount -m criptata
</pre>
o anche semplicemente:
<pre>
$ cryptmount criptata
</pre>
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.


case $1 in
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.
        monta)
                echo "Verifica presenza SD:"
                if [ -b /dev/mmcblk0p1 ] ; then
                    echo "."
                else
                    echo "La periferica non è inserita!"
                    exit 2
                fi


                if [ $? = 0 ]; then /sbin/cryptsetup luksOpen /dev/mmcblk0p1 criptata
Per smontare la periferica criptata basta, essendo autenticati come l'utente che ha montato il volume o super user:
                fi
<pre>
$ cryptmount -u criptata
</pre>
 
=== Gestione manuale ===
Per una gestione manuale dei volumi, bisogna usare i comandi <code>losetup</code>, <code>crytpsetup</code> e <code>mount</code>.<br/>
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]].
 
== Approfondimenti ==
=== Moduli del kernel ===
==== Kernel precompilato Debian ====
{{Box|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.<br/>
In un terminale eseguiamo:
<pre>$ cat /proc/crypto</pre>
e dovremmo ottenere (in base anche ai moduli caricati) qualcosa tipo:
<pre>
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</pre>
Ovviamente a noi interessano le sezioni che iniziano con <code>'''name        : aes'''</code>. Se non dovessero comparire dobbiamo controllare che i moduli responsabili dell'<code>'''aes'''</code> siano caricati e ottenere un output simile a questo:
<pre>
$ lsmod |grep aes
aes_i586              16608  0  
aes_generic            37066  1 aes_i586
</pre>
(o aes-x86_64 in caso di architettura per kernel amd64).<br/>
AES ci serve per la cifratura, ora dobbiamo pensare all'hash. Per l'hash serve l'algoritmo <code>sha256</code> (ovviamente potremmo voler usare lo <code>sha512</code>, per cui basterebbe cambiare il 256 in 512 in ogni occorrenza). È precompilato nel kernel Debian, ma non è detto che sia caricato (nel <code>/proc/crypto</code>, soprariportato, non è infatti presente) quindi carichiamolo:
<pre># modprobe sha256_generic</pre>
Nel file <code>/proc/crypto</code> si dovrebbero essere aggiunte le seguenti righe:
<pre>
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</pre>


                if [ $? = 0 ]; then
Infine l'ultimo modulo da caricare nel kernel è <code>dm-crypt</code>, la cui assenza impedisce a cryptmount di completare le operazioni richieste.<pre># modprobe dm-crypt</pre>
                    mount /dev/mapper/criptata /home/'''nomeutente'''/criptata
                fi


                if [ $? != 0 ]; then
==== Kernel personalizzato ====
                    echo "Il file system cifrato non può essere montato."
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:
                    /sbin/cryptsetup luksClose criptata
<pre>AES cipher algorithms</pre>
                fi
o la strettamente legata:
        ;;
<pre>AES cipher algorithms (i586)</pre>
        smonta)
#Smonto il file system criptato e controllo che lo smontaggio sia avvenuto correttamente
                umount /dev/mapper/criptata
                if [ $? != 0 ]; then
                    echo "Smontaggio non riuscito."
                fi


#Chiudo il nodo in /dev/mapper e controllo
=== Pagine di manuale ===
                /sbin/cryptsetup luksClose criptata
*Principali:
                if [ $? = 0 ]; then
::<code>$ man cryptsetup</code>
                    echo "Nodo cifrato in /dev/mapper rimosso."
::<code>$ man cryptmount</code>
                else echo "Chiusura periferica criptata non riuscita"
*Per il file di configurazione di <code>cryptmount</code>:
                fi
::<code>$ man cmtab</code>
        ;;
        *)
        echo "Usage: $1 {monta|smonta}" >&2
        exit 1
        ;;
esac</pre>


{{Autori
|Autore = [[Utente:GipPasso|GipPasso]]
|Estesa_da=
: [[Utente:S3v|S3v]] 15:49, 3 mag 2016 (CEST) (cryptmount) (CEST)
|Verificata_da=
: [[Utente:HAL 9000|HAL 9000]] 10:07, 29 set 2019 (CEST)
|Numero_revisori = 1
}}


: [[Utente:GipPasso|GipPasso]]
[[Categoria:Filesystem]]
[[Categoria:Crittografia]]
HAL 9000
3 581

contributi

Estratto da "https://guide.debianizzati.org/index.php/Speciale:DiffMobile/15855...43279"

Menu di navigazione