Guide@Debianizzati.Org

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

Pagina Discussione

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

Versione delle 08:09, 29 set 2019

16 733 byte aggiunti ,  29 set 2019
m
→‎Creazione di una voce in cmtab
Nessun oggetto della modifica
 
(74 versioni intermedie di 8 utenti non mostrate)
Riga 1: Riga 1:
==Introduzione==
{{Versioni compatibili|Wheezy|Jessie|Stretch|Buster}}
In questo tutorial analizzeremo apt-proxy.
Apt-proxy � un comodo strumento per mantenere una cache dei pacchetti Debian gi�
scaricati, riuscendo cos� a velocizzare il download da parte di altri client
connessi alla stessa Lan ed a risparmiare un po' di banda, soprattutto nei casi
in cui questa � a pagamento =)


==Installazione==
== Introduzione ==
Per installarlo � sufficiente dare il seguente comando:
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/>
<pre>
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/>
# apt-get install apt-proxy
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.
</pre>


{{Box|NOTA|In questo periodo sta avvenendo la transizione tra la versione 1 e la versione 2. In questo howto verranno analizzate entrambe le versioni, e verr� illustrato anche il passaggio dalla v1 alla v2.}}
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 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/>
È 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 ==
=== Moduli da caricare ===
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.


==Configurazione==
=== Pacchetti necessari ===
Per ottenere <code>cryptmount</code> e <code>cryptsetup</code> servirà installare i relativi pacchetti con [[privilegi di amministrazione]]:
<pre>
# 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.


===Versione 1===
== 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>.


La configurazione � molto semplice; tutti i parametri sono contenuti in un file:
== Cryptsetup ==
/etc/apt-proxy/apt-proxy.conf
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''.


Ne riporto una versione semplificata, in cui le varie variabili di
=== File ordinario montato in loop ===
configurazione sono commentate:
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]]:
<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''')


=== 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).
{{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}}
Creiamo la partizione LUKS, con parametri di default (la scelta raccomandata, salvo esigenze particolari):
<pre>
<pre>
-------------------------------------------------------
# cryptsetup --verify-passphrase --verbose luksFormat /dev/periferica
# imposta la directory in cui salvare al cache
APT_PROXY_CACHE=/var/cache/apt-proxy


# Esempio per il repository ufficiale Debian
WARNING!
# Debian main
========  ========
#
This will overwrite data on /dev/periferica irrevocably.
# Qui di seguito sono riportate le righe da inserire in un ipotetico
sources.list
# ovviamente sostituendo APTPROXY con l'indirizzo del server che funge da proxy.
#deb http://APTPROXY:9999/debian stable main contrib non-free
#deb http://APTPROXY:9999/debian woody main contrib non-free
#deb http://APTPROXY:9999/debian sarge main contrib non-free
#deb http://APTPROXY:9999/debian sid main contrib non-free
#deb http://APTPROXY:9999/debian project/experimental/main/binary-$(ARCH)/


# Qui aggiungiamo un backend, indicando la directory in cui verr� creata la
Are you sure? (Type uppercase yes):
cache
</pre>
# La prima riga contiene la dichiarazione del backend, la seconda indica un
Come dice il messaggio bisogna rispondere con uno <code>'''YES'''</code> interamente maiuscolo.<br/>
repository
Ci verrà di seguito chiesta una parola d'ordine e la sua conferma; mentre le digiteremo non vedremo nulla cambiare nel terminale:
# locale (quello della cache), dalla seconda alla penultima sono indicati i vari
<pre>
mirror
Enter LUKS passphrase:
# ufficiali, l'ultima indica un collegamento `alternativo` a http, cio� via
Verify passphrase:
ftp...
# Da notare l'importanza delle backslash a fineriga (ultima riga esclusa)
add_backend /debian/  
$APT_PROXY_CACHE/debian/
http://ftp2.it.debian.org/debian/
# http://ftp.de.debian.org/debian/
# http://ftp.uk.debian.org/debian/
# +ftp.us.debian.org::debian/


Command successful.
</pre>


=== 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 <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>


############################## OTHER VARS ##################################
=== Rimozione della periferica criptata ===
# Qui sono presenti le variabili di configurazione
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>
# Dopo quanti giorni devono essere eliminati i pacchetti vecchi;
# umount /mnt/prova
# Se impostata a 0, attiva l'eliminazione immediata dei vecchi pacchetti
# cryptsetup close criptata
(sconsigliata)
</pre>
CLEANUP_DAYS=14


# Dopo quanti giorni verranno cancellati i pacchetti considerati vecchi,
=== Rimozione di una loop device ===
raramente utilizzati
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:
# Commentarla per disabilitare questa funzione.
<pre>
CLEAN_SWEEP=60
# losetup -d /dev/loop0
</pre>


# Il numero massimo di versioni di un pacchetto da conservare in memoria.
== Cryptmount ==
# Commentarla per disabilitare questa funzione.
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/>
MAX_VERSIONS=2
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
      ...
}


# Frequenza massima, in minuti, degli aggiornamenti dei pacchetti
nome2 {
# Impostare un valore abbastanza alto per avere delle buone performance.
      chiave=valore
BACKEND_FREQ=240
      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> .


# Quanti secondi devono passare prima che RSYNC vada in TimeOut
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.
RSYNC_TIMEOUT=30


# Quanti secondi devono passare prima che RSYNC vada in TimeOut
=== File system criptato su partizione ===
WGET_TIMEOUT=30
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>.


# Consente di impostare il path dell'eseguibile di wget e/o di appendere delle
==== Creazione di una voce in <code>cmtab</code> ====
opzioni all'eseguibile
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à:
#WGET=wget
<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).


# Consente di impostare il path dell'eseguibile di rsync e/o di appendere delle
==== Creazione della chiave ====
opzioni all'eseguibile
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.
#RSYNC=rsync
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).


# Per appoggiarsi ad un proxy per il download dei pacchetti:
Durante questa fase verrà chiesto:
#export http_proxy=http://proxy:8080/
#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.
#export ftp_proxy=http://proxy:8080/
#di inserire per due volte una password a scelta.
# in caso di necessit�, � possibile gestire l'autenticazione:
#export http_proxy=http://user:pass@proxy:8080/
#export ftp_proxy=http://user:pass@proxy:8080/


-------------------------------------------------------
==== Creazione del file system ====
L'operazione finale consiste nella creazione del file system vero e proprio e nella sua mappatura.<br/>
Diciamo a <code>cryptmount</code> di preparare il volume per la creazione del file system:
<pre>
# cryptmount --prepare partizione_criptata
</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>
</pre>


=== 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.


===Versione 2===
==== Creazione di una voce in <code>cmtab</code> ====
 
Analogamente a quanto visto per una partizione, è necessario creare una voce nel file <code>/etc/cryptmount/cmtab</code>. Ad esempio:
In questo periodo � stata rilasciata la versione 2 di apt-proxy
<pre>
(http://apt-proxy.sourceforge.net/).
file_criptato {
Le migliorie sono tante, e invito a fare una visitina al sito ufficiale.
        keyformat=luks
Prima di passare all'analisi del nuovo file di configurazione, vorrei
        dev=/home/pippo/file_criptato.img
sottolineare che, ora, apt-proxy gira come servizio, con relativo script di
        keyfile=/home/pippo/file_criptato.img
avvio/riavvio/stop: /etc/init.d/apt-proxy. Questo vuole dire che, ogni volta che viene modificato il file, conviene riavviare il server apt-proxy.
        dir=/home/pippo/cryptfile
 
        fstype=ext4
Analizziamo il file di configurazione di questa nuova versione.
        mountoptions=nodev,nosuid,noexec
Come per il file di configurazione precedente, riporto una copia del mio file
}
di configurazione, commentando i vari parametri.
</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.


==== Creazione del file ====
A differenza di quanto avveniva per la partizione, in questo caso il file deve essere effettivamente creato con:
<pre>
<pre>
[DEFAULT]
$ dd if=/dev/zero of=/home/pippo/file_criptato.img bs=1M count=512
;; Tutti i valori usati per il tempo sono espressi in secondi, � possibile
;; per� indicarli anche in minuti(m), ore(h) o giorni(d), postponendo al numero
;; la lettera distintiva dell'unit� di misura.
 
;; � possibile impostare l'ip al quale risponde il server
;; utile per limitare l'accesso (ad esempio non renderlo accessibile
;; dall'esterno)
;address = 192.168.0.254
 
;; Porta a cui il server presta ascolto
port = 9999
 
;; Intervallo di refresh per Packages/Sources/Contents
;;
;; Intervallo minimo prima di aggiornare un file
min_refresh_delay = 240
 
;; Vita minima di un file prima che venga aggiornato (NOT YET IMPLEMENTED)
;min_age = 23h
 
;; Rimuovi il commento da questa direttiva per fare in modo che
;; apt-proxy continui a scaricare anche se il client si disconnettr
;; Utile per connessioni always-on (ADSL...)
;; complete_clientless_downloads = 1
 
;; Debugging settings.
;; for all debug information use this:
;; debug = all:9
debug = all db:3
 
;; Debugging remote python console
;; Do not enable in an untrusted environment
;telnet_port = 9998
;telnet_user = apt-proxy
;telnet_password = secret
 
;; Timeout mentre si ricevono dati da un server
timeout = 30
 
;; Cache directory di apt-proxy
cache_dir = /var/cache/apt-proxy
 
;; Usa FTP passivo (default=on)
;passive_ftp = on
 
;; Usa un proxy apt
;http_proxy = host:port
 
;; Disable HTTP pipelining within apt-proxy (for test purposes)
;disable_pipelining=1
 
;;--------------------------------------------------------------
;; Cache housekeeping
 
;; Time to perform periodic housekeeping:
;;  - delete files that have not been accessed in max_age
;;  - scan cache directories and update internal tables
cleanup_freq = 60d
 
;; Maximum age of files before deletion from the cache (seconds)
max_age = 14d
 
;; Maximum number of versions of a .deb to keep per distribution
max_versions = 2
 
;; Add HTTP backends dynamicaly if not already defined? (default=on)
;dynamic_backends = on
 
;;---------------------------------------------------------------
;;---------------------------------------------------------------
;; Backend servers
;;
 
;[debian]
;Questo backend � stato commentato, per prevenire problemi durante
;l'importazione dei backend dalla versione 1onfiguration
;
;;; The main Debian archive
;;; � possibile sovrascrivere la direttiva `timeout` di default:
;;timeout = 30
;
;;; Rsync server (NOT YET IMPLEMENTED)
;;;rsyncpackages = rsync://ftp.de.debian.org/debian
;
;;; Backend server, in ordine di preferenza
;backends =
;      http://ftp.us.debian.org/debian
;      http://ftp.de.debian.org/debian
;      http://ftp2.de.debian.org/debian
;      ftp://ftp.uk.debian.org/debian
;
;
;[non-US]
;; Debian non-US archive
;timeout non � stata sovrascritta, quindi verr� mantenuto il
;valore di default
;backends =
;      http://ftp.uk.debian.org/debian-non-US
;      http://ftp.de.debian.org/debian-non-US
;      ftp://ftp.uk.debian.org/debian
 
;[security]
;Questo backend � stato commentato, per prevenire problemi durante
;l'importazione dei backend dalla versione 1onfiguration
;
;;; Debian security archive
;backends =
;      http://security.debian.org/debian-security
;      http://ftp2.de.debian.org/debian-security
;
;[openoffice]
;; OpenOffice.org packages
;backends =
;      http://ftp.freenet.de/pub/debian-openoffice
;      http://ftp.sh.cvut.cz/MIRRORS/OpenOffice.deb
;      http://borft.student.utwente.nl/debian
 
;[apt-proxy]
;; Apt-proxy new versions
;backends = http://apt-proxy.sourceforge.net/apt-proxy
 
;[backports.org]
;; backports.org
;backends = http://backports.org/debian
 
;[blackdown]
;;; Blackdown Java
;;backends = http://ftp.gwdg.de/pub/languages/java/linux/debian
;
;
;[debian-people]
;; people.debian.org
;backends = http://people.debian.org
 
;[emdebian]
;; The Emdebian project
;backends = http://emdebian.sourceforge.net/emdebian
 
;[rsync]
;; Un esempio di utilizzo con un server rsync. Non � raccomandato
;; il suo utilizzo, a meno che non sia l'unico servizio disponibile:
;; rsync � molto efficiente solo nel trasferimento di dati non compressi
;; e carica molto il server.
;backends = rsync://ftp.uk.debian.org/debian
 
[debian]
backends =
        http://ftp.it.debian.org/debian
 
[non-US]
backends =
        http://debian.fastweb.it/debian-non-US
        http://ftp.debian.org/debian-non-US
        http://ftp.it.debian.org/debian-non-US
        http://ftp2.it.debian.org/debian-non-US
 
[security]
backends =
        http://security.debian.org
 
[blackdown]
backends =
        http://ftp.gwdg.de/pub/languages/java/linux/debian
 
[marillat]
backends =
        ftp://ftp.nerim.net/debian-marillat
 
[jedit]
backends =
        http://dl.sourceforge.net/sourceforge/jedit
 
[mythtv]
backends =
        http://dijkstra.csh.rit.edu:8088/~mdz/debian/
</pre>
</pre>
Per un file delle dimensioni di circa 512MB.<br/>
Notare che il comando va impartito come '''utente normale'''.


Ok, ora abbiamo visto il file di configurazione...che dire: semplicissimo!
==== Creazione della chiave ====
Prima di concludere la parte relativa alla configurazione del server, vorrei
La creazione della chiave è identica a quella già vista per una partizione e valgono ancora le considerazioni precedentemente illustrate, cambia solo il nome identificativo:
mostrare alcuni comandi importanti, utili per la configurazione e l'utilizzo
di apt-proxy:
 
<pre>
<pre>
# apt-proxy-import
# cryptmount --generate-key 32 file_criptato
</pre>
</pre>


Comando utilissimo durante la prima installazione: consente di importare dei
==== Creazione del file system ====
pacchetti Debian gi� scaricati nella cache di apt-proxy.
Anche quest'operazione è in tutto e per tutto identica a quanto visto in precedenza:
Utilizzo:
<pre>
 
# cryptmount --prepare file_criptato
<pre>  
# mke2fs -t ext4 /dev/mapper/file_criptato
# apt-proxy-import --import-dir=/dir/contentente/i/pacchetti
# cryptmount --release file_criptato
# apt-proxy-v1tov2
</pre>
</pre>


Comodissima utility che converte il file di configurazione della versione 1 in
== Uso del volume cifrato ==
uno compatibile con la versione 2.
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).
Utilizzo:
Ogni utente può dare:
 
<pre>
<pre>
# apt-proxy-v1tov2 [v1_conf [v2_sample_conf]] > v2_conf
$ cryptmount -m criptata
</pre>
</pre>
 
o anche semplicemente:
Di default utilizza /etc/apt-proxy/apt-proxy.conf per v1_conf e
/etc/apt-proxy/apt-proxy-v2.conf per v2_sample_conf.
 
<pre>
<pre>
# /etc/init.d/apt-proxy
$ cryptmount criptata
[start|stop|restart|force-reload]
</pre>
</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.


Script di gestione di apt-proxy:
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.
start: avvia il server;
stop: lo arresta;
restart: lo riavvia;
force-reload: Forza la rilettura del file di configurazione.
 
==Utilizzo==
 
Niente di pi� semplice: basta modificare il proprio
/etc/apt/sources.list
mettendo come server indirizzo_server:9999
 
 
===Esempio===
Se prima, nel nostro sources.list avevamo una riga del tipo:


Per smontare la periferica criptata basta, essendo autenticati come l'utente che ha montato il volume o super user:
<pre>
<pre>
deb http://ftp2.it.debian.org/debian/ testing main
$ cryptmount -u criptata
non-free contrib
</pre>
</pre>


non ci baster� che seguire questi passi, per configurare il server e i client:
=== 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]].


1) inseriamo il backend nel server, se non � gi� presente:  
== Approfondimenti ==
<pre>[debian]
=== Moduli del kernel ===
backends =
==== Kernel precompilato Debian ====
http://ftp2.it.debian.org/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.}}
</pre>
La prima cosa da controllare prima di cimentarsi nella criptazione è l'abilitazione del kernel a usare l'algoritmo AES.<br/>
 
In un terminale eseguiamo:
2) modifichiamo il soruces.list dei client:
<pre>$ cat /proc/crypto</pre>
e dovremmo ottenere (in base anche ai moduli caricati) qualcosa tipo:
<pre>
<pre>
deb http://indirizzoserver:9999/debian/ testing main non-free contrib
name        : aes
</pre>
driver      : aes-asm
module      : aes_i586
priority    : 200
refcnt      : 1
selftest    : passed
type        : cipher
blocksize    : 16
min keysize  : 16
max keysize  : 32


3) aggiorniamo apt-proxy
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>
<pre>
# /etc/init.d/apt-proxy force-reload
$ lsmod |grep aes
aes_i586              16608  0
aes_generic            37066  1 aes_i586
</pre>
</pre>
 
(o aes-x86_64 in caso di architettura per kernel amd64).<br/>
4) aggiorniamo con
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>
<pre>
# apt-get update
name        : sha256
</pre>
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>


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>


Fine!
==== 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:
<pre>AES cipher algorithms</pre>
o la strettamente legata:
<pre>AES cipher algorithms (i586)</pre>


=== Pagine di manuale ===
*Principali:
::<code>$ man cryptsetup</code>
::<code>$ man cryptmount</code>
*Per il file di configurazione di <code>cryptmount</code>:
::<code>$ man cmtab</code>


---- [[User:MaXeR|MaXeR]]
{{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
}}


[[Categoria:Apt]]
[[Categoria:Filesystem]]
[[Categoria:Repository]]
[[Categoria:Crittografia]]
HAL 9000
3 581

contributi

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