%% gpg.tex (to be included in cryptoapp.tex and shell.tex)
%%
%% Copyright (C) 2006-2018 Simone Piccardi and Truelite Srl.
%%
%% This work is licensed under the Creative Commons Attribution-ShareAlike 4.0
%% International License. To view a copy of this license, visit
%% \url{http://creativecommons.org/licenses/by-sa/4.0/} or send a letter to
%% Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
%%
%% Sicurezza: Parte della sezione sulle applicazioni di sicurazza, relativa a
%% GPG, inclusa da più parti
%%
%% S. Piccardi Jan. Apr 2006
%% 
%% gpg.tex
%%

%%
%% Questa parte viene anche usata da AGL per la parte su gpg nella sezione sui
%% comandi per la verifica di integrità (inclusa da shell.tex)
%%

Benché esistano diversi programmi di gestione dotati di interfaccia grafica,
noi tratteremo soltanto la versione originale di GPG a riga di comando,
\index{comando!\texttt{gpg}} \texttt{gpg}. Il programma è estremamente vasto e
complesso, le varie operazioni che può eseguire vengono attivate tramite un
lunghissimo elenco di opzioni la gran parte delle quali deve essere
specificata in formato esteso.

Alcune di queste costituiscono dei veri e propri sottoprogrammi e devono
essere usate singolarmente, attivando speciali operazioni interattive ed anche
una riga di comando interna. Altre controllano le operazioni più ordinarie e
possono richiedere o meno l'indicazione di un argomento al programma, il cui
significato varia a seconda dell'opzione stessa. Infine alcune possono essere
usate in combinazione con le altre per controllare le modalità di
funzionamento del programma.

Si sono riportate le opzioni più comuni nell'uso ordinario del programma, che
in genere sono quelle per cui è presente anche una versione in forma non
estesa, in tab.~\ref{tab:gpg_main_options}. Di tutte le altre tratteremo qui
soltanto le più rilevanti, mentre per gli approfondimenti e tutti i dettagli
si rimanda alla abbondante documentazione disponibile a partire dalla pagina
di manuale.

Il primo passo per l'uso di GPG è quello di generare una propria coppia di
chiavi. Questa è in genere una operazione da eseguire una volta per tutte, e
non rientra nell'uso ordinario del programma. Per farlo occorre invocare
\texttt{gpg} con l'opzione \texttt{-{}-gen-key} che fa partire la procedura
interattiva in cui vengono richieste tutte le informazioni necessarie. Dato
che il programma è di uso personale, questo deve essere usato come utente
normale, e tutti i suoi dati verranno mantenuti nella directory
\texttt{.gnupg} della propria home directory. 

Questo significa anche che non è il caso di usarlo su macchine di cui non si è
il solo amministratore, perché per quanto le chiavi private siano protette da
una \textit{passphrase} esistono molti modi (ad esempio l'installazione di una
versione ``\textsl{taroccata}'' del programma) con cui un amministratore
potrebbe impossessarsi della vostra chiave privata.

Un esempio di creazione delle proprie chiavi, fatto passo per passo, è quello
che riportiamo di seguito. Anzitutto occorre scegliere algoritmi di
crittografia, dimensione delle chiavi e scadenza:
\begin{Console}
$ \textbf{gpg --gen-key}
gpg (GnuPG) 1.4.11; Copyright (C) 2010 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
Your selection? \textbf{1}
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 
Requested keysize is 2048 bits
Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 
Key does not expire at all
Is this correct? (y/N) \textbf{y}
\end{Console}
%$
ed in questo caso si sono accettati i default per le impostazioni e si è
risposto di sì alla domanda finale (in caso di errore in una delle scelte si
può ripetere la procedura rispondendo no), una volta fatto questo bisogna
scegliere un opportuno \textit{User ID}:
\begin{Console}
You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
    "Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"

Real name: \textbf{Truelite Srl}
Email address: \textbf{info@trl.tl}
Comment: \textbf{Truelite}
You selected this USER-ID:
    "Truelite Srl (Truelite) <info@trl.tl>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? \textbf{O}
\end{Console}
dove vengono richieste le varie informazioni che ne fanno parte. Una volta
completata la fornitura delle informazioni di identificazione verrà chiesta
una \textit{passphrase} per proteggere la propria chiave privata. Dato che la
\textit{passphrase} costituisce l'unica difesa contro un uso non autorizzato
della chiave (in caso di compromissione o perdita della macchina su cui si
lavora) è opportuno che sia scelta con molta cura e sia sufficientemente lunga
e complessa; non venendo visualizzata la si dovrà immettere due volte per
conferma:
\begin{Console}
You need a Passphrase to protect your secret key.

Enter passphrase: 
Repeat passphrase:
\end{Console}
una volta fatto questo il programma provvederà alla generazione della chiave
privata, per farlo è necessario avere una quantità sufficiente di numeri
casuali, cosa che in genere causa la richiesta di generare sufficiente
entropia nel sistema con varie azioni,\footnote{la pressione di tasti fa
  riferimento alla tastiera fisica, se si esegue il comando in remoto con una
  sessione \texttt{ssh} la cosa non avrà alcun effetto (la rete non è
  considerata una fonte affidabile di rumore).} una volta ottenuta la quale
verranno creati i dati necessari e stampato un riassunto conclusivo:
\begin{Console}
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

Not enough random bytes available.  Please do some other work to give
the OS a chance to collect more entropy! (Need 144 more bytes)
....+++++
...........+++++
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

Not enough random bytes available.  Please do some other work to give
the OS a chance to collect more entropy! (Need 24 more bytes)
..+++++
..+++++
gpg: /home/piccardi/.gnupg/trustdb.gpg: trustdb created
gpg: key 58AF19F7 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   2048R/58AF19F7 2011-07-07
      Key fingerprint = 3A62 34E7 E2EB E1DA 3EF5  9D60 66F3 F29A 58AF 19F7
uid                  Truelite Srl (Truelite) <info@trl.tl>
sub   2048R/F1493ABF 2011-07-07
\end{Console}

Si tenga conto che \texttt{gpg} consente di gestire anche più coppie di
chiavi; se pertanto si vogliono usare due chiavi diverse per due identità
diverse si potrà ripetere l'operazione di generazione delle chiavi una seconda
volta, e la nuova chiave verrà aggiunta nel proprio \textit{keyring} (il
``\textsl{portachiavi}'') all'interno di \texttt{.gnupg}. È sempre possibile
avere due chiavi con riferimento ad un \textit{User ID} identico, in caso di
ambiguità infatti si potrà fare comunque riferimento al \textit{Key-ID} per
indicare quale delle chiavi si vuole usare.

Un secondo passo iniziale, che si consiglia di mettere in pratica subito dopo
la creazione di una coppia di chiavi, è quello di generare un certificato di
revoca. Questa è una misura di precauzione nei confronti dell'eventualità
della perdita totale della chiave privata, (come lo smarrimento o il furto
dell'unico computer su cui la si teneva) o di impossibilità di accesso alla
stessa, (ad esempio se non ci si ricorda più la passphrase) che permette di
invalidare permanentemente la propria chiave PGP anche quando questa non è più
disponibile. È ovviamente sempre possibile generare in un secondo tempo il
certificato in caso di perdita o compromissione della propria chiave, ma per
farlo occorre averne a disposizione almeno una copia.

Ovviamente occorrerà proteggere adeguatamente tale certificato di revoca,
perché se questo pervenisse in mano ad un terzo ostile questi potrebbe
invalidare la chiave a cui fa riferimento. La sua perdita però è meno dannosa
rispetto a quella della chiave stessa, in quanto il suo scopo è solo quello
della revoca, e quindi non è possibile usarlo per impersonare il titolare
della chiave.

Per la generazione del certificato di revoca occorre usare l'opzione
\texttt{-{}-gen-revoke} che, come molte altre opzioni di \texttt{gpg},
richiede che si specifichi come argomento del comando la chiave a quale si fa
riferimento. Questo si può fare in due modi, si può indicare il valore in
esadecimale del \textit{Key-ID} della chiave scelta, o si può indicare una
stringa il cui testo verrà usato per individuare la chiave con una ricerca nel
testo degli \textit{User ID} ad esse associati; nel caso di corrispondenze
multiple verrà sempre selezionata la prima, per evitare le ambiguità occorre
usare il \textit{Key-ID}.

Un esempio della generazione del certificato di revoca, in cui si è usata
anche l'opzione \texttt{-{}-output} per indicare un file di uscita (altrimenti
il testo del certificato sarebbe stato stampato sullo \textit{standard
  output}), è il seguente:
\begin{Console}
$ \textbf{gpg --output revoca.asc --gen-revoke Truelite}
sec  2048R/58AF19F7 2011-07-07 Truelite Srl (Truelite) <info@trl.tl>

Create a revocation certificate for this key? (y/N) \textbf{y}
Please select the reason for the revocation:
  0 = No reason specified
  1 = Key has been compromised
  2 = Key is superseded
  3 = Key is no longer used
  Q = Cancel
(Probably you want to select 1 here)
Your decision? \textbf{0}
Enter an optional description; end it with an empty line:
> \textbf{Revoca precauzionale}
> 
Reason for revocation: No reason specified
Revoca precauzionale
Is this okay? (y/N) \textbf{y}

You need a passphrase to unlock the secret key for
user: "Truelite Srl (Truelite) <info@trl.tl>"
2048-bit RSA key, ID 58AF19F7, created 2011-07-07

ASCII armored output forced.
Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The print system of
your machine might store the data and make it available to others!
\end{Console}
%$


Una volta fatto questo si otterrà all'interno del file \texttt{revoca.asc} (la
convenzione è quella di usare l'estensione \texttt{.asc} per i file che
contengono rappresentazioni testuali delle chiavi PGP) si otterrà un contenuto
del tipo:
\begin{FileExample}[label=revoca.asc]
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.11 (GNU/Linux)
Comment: A revocation certificate should follow

iQEzBCABAgAdBQJOAKulFh0AUmV2b2NhIHByZWNhdXppb25hbGUACgkQm3VwX32z
UE0hNwgA2/+LV+6QGlVrDBRgFwoEoKgq378s9S6Jy0hC/Yru52DnAVgV/SoUvTj3
...
jIG1qsLdzLJCNzNf+Rkyh6ywGsOjWw==
=g2AK
-----END PGP PUBLIC KEY BLOCK-----
\end{FileExample}
e si noti come in precedenza il comando ci abbia notificato che è stata
forzata una uscita in formato testuale (il cosiddetto \textit{ASCII armored});
questo rende possibile anche una semplice stampa del certificato.

Una volta che si disponga di una propria coppia di chiavi si dovrà iniziare ad
utilizzarla. Perché altri ci possano inviare messaggi cifrati dovranno però
disporre della nostra chiave pubblica, lo stesso vale qualora volessero
firmarla dopo aver verificato la nostra identità, occorre pertanto avere un
meccanismo di distribuzione.

Il modo più semplice per distribuire la propria chiave pubblica è quello di
pubblicarla su un file, per questo esiste l'opzione \texttt{-{}-export} che
consente di salvare un chiave pubblica in un formato standard che la renda
utilizzabile da terzi. Se usata da sola i dati verranno stampati a video in
formato binario, pertanto è comune usare l'opzione \texttt{-{}-output}
(abbreviabile in \texttt{-o}) per indicare un file di destinazione e l'opzione
\texttt{-{}-armor} (abbreviabile in \texttt{-a}) per richiedere la codifica
\textit{ASCII armored}. In questo modo la chiave sarà in formato testo, che
può essere facilmente scambiato per email o pubblicato, e la cui copia non
richiede nulla di più di un taglia ed incolla.

Dato che come accennato un \textit{keyring} personale può contenere diverse
chiavi, sia pubbliche che private, anche \texttt{-{}-export} richiede che si
indichi quella che si vuole esportare con un \textit{User ID} o un
\textit{Key-ID}, con le stesse convenzioni riguardo la scelta \textit{User ID}
sulla base della stringa passata come argomento già illustrate per
\texttt{-{}-gen-revoke}.  Un esempio di esportazione è allora il seguente:
\begin{Console}
$ \textbf{gpg --output key.gpg --armor --export info@trl.tl}
\end{Console}
%$
e si otterrà un contenuto di \texttt{key.gpg} del tipo:
\begin{FileExample}[label=key.gpg]
 -----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.11 (GNU/Linux)

mQENBE4ApmQBCADv7AuurV1SnpOtylZazkl39QOAQdMhGyPtr8AVFJOKVd8qr5Da
...
awgseHHXiHZD2Mdc7p5SQTjqzWTW1ZcM1zItbpkt8xjcXCdCX8NhXyQT2msqKyGT
=TwxL
-----END PGP PUBLIC KEY BLOCK-----
\end{FileExample}

Una volta ottenuto il file con la chiave, o il relativo testo, lo si potrà
inviare ai propri corrispondenti, ma una delle funzionalità più interessanti
di \texttt{gpg} è che il programma supporta direttamente anche l'interazione
con i cosiddetti \textit{keyserver}, una rete di server presenti su Internet e
dedicati alla distribuzione delle chiavi, che possono essere interrogati
direttamente tramite il comando con le due opzioni \texttt{-{}-send-keys} e
\texttt{-{}-recv-keys}.

In particolare \texttt{-{}-send-keys} consente di inviare ad un
\textit{keyserver} una qualunque delle chiavi pubbliche che si hanno nel
portachiavi, da indicare esclusivamente per \textit{Key-ID}. Pertanto si potrà
eseguire la pubblicazione di una chiave con:
\begin{Console}
$ \textbf{gpg --send-keys 58AF19F7}
\end{Console}
%$
ed il comando inserirà la chiave nel \textit{keyserver} la prima volta, e la
aggiornerà con eventuali dati (altre identità o firme ricevute) le volte
successive.

Una volta che una chiave è stata pubblicata su un \textit{keyserver} sarà
possibile per chiunque scaricarla direttamente via rete, \texttt{gpg} supporta
una specifica opzione, \texttt{-{}-recv-keys}, che scarica ed importa
direttamente una chiave, sempre indicata per \textit{Key-ID}, con un comando
del tipo:
\begin{Console}
$ \textbf{gpg --recv-keys 2A972F9D}
gpg: requesting key 2A972F9D from hkp server keys.gnupg.net
gpg: key 2A972F9D: public key "Simone Piccardi (Truelite SrL) <piccardi@truelite.it>" imported
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: Total number processed: 1
gpg:               imported: 1
\end{Console}
%$

Nei due esempi precedenti si è sempre usato il \textit{keyserver} di default,
\texttt{keys.gnupg.net}, ma è sempre possibile usare l'ulteriore opzione
\texttt{-{}-keyserver} per specificare un \textit{keyserver} alternativo;
l'opzione richiede l'indicazione dello stesso come parametro da specificare in
forma di indirizzo IP o di nome a dominio.\footnote{in realtà il parametro ha
  una forma generica più complessa:
  \texttt{scheme://keyserver.name.or.ip:port} dove \texttt{scheme} può
  assumere i valori \texttt{hkp}, \texttt{ldap} o \texttt{mailto} per l'uso di
  diversi schemi di comunicazione (via HTTP, LDAP o email); dato che la gran
  parte dei \textit{keyserver} usa il protocollo via web, si omette
  \texttt{hkp://} essendo questa il default.}

Se invece si dispone direttamente di un file contente una chiave la si potrà
importare direttamente con l'opzione \texttt{-{}-import}, se non si specifica
altro il comando leggerà la chiave dallo standard input, altrimenti si potrà
passare come argomento il file che la contiene. Pertanto se si è scaricata la
chiave con cui viene firmato l'archivio di Debian Squeeze nel file
\texttt{archive-key-6.0.asc}, la si potrà importare con:
\begin{Console}
$ \textbf{gpg --import archive-key-6.0.asc}
gpg: key 473041FA: public key "Debian Archive Automatic Signing Key (..." imported
gpg: Numero totale esaminato: 1
gpg:              importate: 1  (RSA: 1)
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
\end{Console}
%$

Si tenga presente che importare una chiave non significa ancora darle alcun
livello di fiducia e che il fatto che sia disponibile su un \textit{keyserver}
non ha nessuna implicazione su questo piano; la chiave resterà considerata
\textit{untrusted} fintanto che non la si sia verificata esplicitamente (ed
eventualmente firmata) o sia firmata da altri corrispondenti dei quali si è
stabilito di avere fiducia (torneremo sulla gestione di questi aspetti più
avanti).

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}{|l|l|p{8cm}|}
    \hline
    \multicolumn{2}{|c|}{\textbf{Opzione}}&\textbf{Significato}\\
    \hline
    \hline
    \texttt{-{}-output}&\texttt{-o}& indica di scrivere l'uscita del comando
                                     sul file passato come parametro.\\ 
    \texttt{-{}-armor} &\texttt{-a}& indica la generazione di una uscita in
                                     testo puro codificato, il cosiddetto
                                     \textit{ASCII armored}.\\
    \texttt{-{}-recipient}&\texttt{-r}& indica il destinatario per cui si
                                     vuole cifrare, da indicare per
                                     \textit{User ID} o \textit{Key-ID}.\\ 
    \texttt{-{}-encrypt}&\texttt{-e}& esegue la cifratura del file indicato
                                      come argomento del comando (o letto
                                      dallo \textit{standard input}).\\ 
    \texttt{-{}-decrypt}&\texttt{-d}& esegue la decifratura del file indicato
                                      come argomento del comando (o letto
                                      dallo \textit{standard input}).\\ 
    \texttt{-{}-sign}   &\texttt{-s}& crea una firma del file indicato
                                      come argomento (o letto
                                      dallo \textit{standard input}).\\ 
    \texttt{-{}-detach-sign}&\texttt{-b}& firma il file indicato
                                      come argomento (o letto
                                      dallo \textit{standard input}) su un
                                      file a parte.\\ 
    \texttt{-{}-local-user}&\texttt{-u}& richiede di usare la chiave privata
                                      corrispondente all'\textit{User ID}
                                      passato come parametro.\\ 
    \texttt{-{}-verify} & --        & richiede la verifica della firma.\\ 
%    \texttt{-{}-}&\texttt{-}& .\\ 
    \hline
  \end{tabular}
  \caption{Principali opzioni di \texttt{gpg}.} 
\label{tab:gpg_main_options}
\end{table}

Una volta completate le operazioni preliminari per creare la propria coppia di
chiavi ed ottenere le chiavi dei corrispondenti che ci interessano, l'uso
ordinario di \texttt{gpg} consiste principalmente nella ricezione e nell'invio
di documenti cifrati o firmati o entrambi. Le opzioni relative a queste
operazioni, insieme alle altre di più comune utilizzo, sono riassunte in
tab.~\ref{tab:gpg_main_options}.

Una volta che si disponga della chiave di un corrispondente si potrà cifrare
un documento per lui con l'opzione \texttt{-{}-encrypt} (abbreviabile in
\texttt{-e}); questa opzione richiede l'uso della successiva opzione
\texttt{-{}-recipient} (abbreviabile in \texttt{-r}) per indicare il
destinatario che deve essere specificato con un ulteriore parametro che ne
identifichi la chiave pubblica, al solito il parametro viene usato come
stringa di ricerca negli \textit{User ID} delle chiavi pubbliche presenti nel
proprio \textit{keyring} o come indicazione del \textit{Key-ID}.

L'opzione \texttt{-r} può essere usata più volte se i destinatari sono più di
uno. Di nuovo i dati da cifrare verranno letti dallo \textit{standard input} a
meno di non indicare un file come argomento, e verranno scritti sullo
\textit{standard output} in formato binario a meno di non usare le opzioni
\texttt{-o} per indicare un file diverso e \texttt{-a} per richiedere
l'\textit{ASCII armored}.

Si tenga presente inoltre che qualora si cifri verso un corrispondente non
verificato il comando stamperà le caratteristiche della chiave e chiederà se
andare avanti lo stesso, fermandosi se non si da una approvazione esplicita;
si otterrà pertanto un risultato del tipo:
\begin{Console}
$ \textbf{gpg -o cifrato.gpg -a -e --recipient 26257B68 chiaro.txt}
gpg: 56EC3680: There is no assurance this key belongs to the named user

pub  2048g/56EC3680 1999-09-23 Christian Surchi <christian@truelite.it>
 Primary key fingerprint: D1E2 9A9D 1712 0E94 8671  834E 0CFF 30E1 2625 7B68
      Subkey fingerprint: 4152 402F 61B0 3D3E 06A4  A587 18B4 4D99 56EC 3680

It is NOT certain that the key belongs to the person named
in the user ID.  If you *really* know what you are doing,
you may answer the next question with yes.

Use this key anyway? (y/N) \textbf{y}
\end{Console}
%$
e si dovrà indicare di usare la chiave esplicitamente.\footnote{la cosa si può
  fare quando quello che interessa è la cifratura dei dati e non l'autenticità
  del corrispondente, per essere ragionevolmente sicuri di questa, e rimuovere
  l'avviso del comando, occorrerà assegnare un livello di fiducia alla chiave,
  cosa che vedremo più avanti.} A questo punto nel file \texttt{cifrato.gpg}
si avrà il messaggio cifrato che si potrà inviare al destinatario, con un
contenuto del tipo:
\begin{FileExample}[label=cifrato.gpg]
-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.11 (GNU/Linux)

hQQOA9pvZzRosObsEBAAsixRt/H5+tCoofUcpKZGCbPB/1Nfb1I9Jgp7pvHoP4xx
...
ni9WWMSr1bnA4oHEcpGNyEe4J5I8r1IF9Rm2N6Tl/J+kElg=
=4ZR7
-----END PGP MESSAGE-----
\end{FileExample}
e soltanto il destinatario potrà decifrarlo.

Qualora invece si voglia firmare un documento, invece di cifrarlo, si hanno
due possibilità: con l'opzione \texttt{-{}-sign} (abbreviabile in \texttt{-s})
si può generare un file firmato, contenente sia il contenuto originale che la
firma digitale. Spesso però è più semplice, ad esempio quando si pubblicano
dei file, mettere a disposizione la firma su un file a parte con la cosiddetta
\textit{detached signature}, nel qual caso occorrerà invece usare l'opzione
\texttt{-{}-detach-sign} (abbreviabile in \texttt{-b}). Qualora si abbiano più
chiavi private (relative a diverse identità) si potrà indicare quale si vuole
usare con l'opzione \texttt{-{}-local-user} (abbreviabile in \texttt{-u}). Un
esempio di creazione di un file firmato è il seguente:
\begin{Console}
$ \textbf{gpg --sign chiaro.txt}
You need a passphrase to unlock the secret key for
user: "Truelite Srl (Truelite) <info@trl.tl>"
2048-bit RSA key, ID 58AF19F7, created 2011-07-07

Enter passphrase: 
\end{Console}
%$
il cui risultato è creare un file binario \texttt{chiaro.txt.gpg} contenente
sia il contenuto del file originario che la firma in forma di messaggio
PGP. L'opzione si può specificare anche insieme a \texttt{-e} così da generare
un messaggio cifrato e firmato allo stesso tempo.  Se invece si vuole firmare
un file e distribuire la \textit{detached signature}, si potrà usare il
comando:
\begin{Console}
$ \textbf{gpg --armor --detach-sign chiaro.txt}
You need a passphrase to unlock the secret key for
user: "Truelite Srl (Truelite) <info@trl.tl>"
2048-bit RSA key, ID 58AF19F7, created 2011-07-07

Enter passphrase: 
\end{Console}
%$
e in questo caso si otterrà un file separato \texttt{chiaro.txt.asc}, in formato
\textit{ASCII armored}, contenente solo la firma nella forma:
\begin{FileExample}[label=chiaro.txt.asc]
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)

iQEcBAABAgAGBQJOFxivAAoJEGbz8ppYrxn3jOoH/i7aSgq/8PxnPIy+vjYAO+GG
...
=7ysA
-----END PGP SIGNATURE-----
\end{FileExample}
che in questo caso dovrà essere distribuito insieme al file originario.

Per verificare una firma si deve usare invece l'opzione \texttt{-{}-verify},
che richiede come argomento il file della firma. Se questo è un messaggio
completo non occorre altro, se questo è una \textit{detached signature} il
comando cerca il file originale sulla base del nome di quello della firma (di
default viene aggiunta l'estensione \texttt{.asc} o \texttt{.sig}), togliendo
l'estensione, ma si può indicare come originale un file qualsiasi
specificandolo come secondo argomento. Pertanto si potrà verificare la firma
del precedente file con:
\begin{Console}
$ \textbf{gpg --verify chiaro.txt.asc} 
gpg: Signature made Fri Jul  8 16:48:15 2011 CEST using RSA key ID 58AF19F7
gpg: Good signature from "Truelite Srl (Truelite) <info@trl.tl>"
\end{Console}
%$
in cui il riferimento al file originale \texttt{chiaro.txt} è automatico.

Se infine si deve decifrare un messaggio che ci è stato inviato l'opzione
relativa è \texttt{-{}-decrypt} (abbreviabile in \texttt{-d}), che richiede si
specifichi il file con il messaggio. Il comando decifra il messaggio e lo
stampa, se questo è firmato verifica automaticamente anche la firma, posto che
si abbia la chiave pubblica del mittente. Un esempio del relativo risultato
è:
\begin{Console}
$ \textbf{gpg --decrypt cifrato.gpg}
You need a passphrase to unlock the secret key for
user: "Truelite Srl (Truelite) <info@trl.tl>"
2048-bit RSA key, ID F1493ABF, created 2011-07-07 (main key ID 58AF19F7)

gpg: encrypted with 2048-bit RSA key, ID F1493ABF, created 2011-07-07
      "Truelite Srl (Truelite) <info@trl.tl>"
PROVA --- PROVA --- PROVA

Prova di testo da cifrare.

PROVA --- PROVA --- PROVA
\end{Console}
%$

Come abbiamo visto in precedenza nel generare un messaggio cifrato per un
corrispondente che non si conosce \texttt{gpg} richiede una conferma esplicita
non potendosi considerare fidata la relativa chiave. Questa non è che la
diretta conseguenza del modello del \textit{web of trust} in cui ciascuno deve
assumersi la responsabilità di decidere di chi si fida o meno. 

%%
%% INIZIO: Sezione specifica da non includere in AGL
%%
\ifx\lpispecificsection\undefined

L'opzione di \texttt{gpg} che consente di effettuare le varie operazioni di
gestione delle chiavi è \texttt{-{}-edit-key} che richiede si passi come
argomento un \textit{User ID} o un \textit{Key-ID}. Quando usata l'opzione
stampa i dati riassuntivi della chiave (con i vari \textit{User ID} ad essa
associati) e poi porta su una riga di comando interna da cui si possono
eseguire le varie operazioni, ad esempio:
\begin{Console}
$ \textbf{gpg --edit-key 2A972F9D}
gpg (GnuPG) 1.4.11; Copyright (C) 2010 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


pub  1024D/2A972F9D  created: 2000-08-14  expires: never       usage: SC  
                     trust: unknown       validity: unknown
sub  4096g/68B0E6EC  created: 2000-08-14  expires: never       usage: E   
[ unknown] (1). Simone Piccardi (Truelite SrL) <piccardi@truelite.it>
[ revoked] (2)  Simone Piccardi <piccardi@fi.infn.it>
[ unknown] (3)  Simone Piccardi <piccardi@firenze.linux.it>
[ unknown] (4)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.it>
[ unknown] (5)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.org>

gpg> 
\end{Console}
%$
e si noti come nella prima parte diano riportati i dati relativi alla validità
(\texttt{validity}) ed al livello di fiducia (\texttt{trust}) associato alla
chiave, che essendo questa stata soltanto scaricata risultano indefiniti.

Una volta ottenuta la riga di comando interna si potranno eseguire le varie
operazioni di gestione della chiave; per queste si potranno usare i vari
comandi interni che \texttt{gpg} mette a disposizione, i principali dei quali
sono riportati in tab.~\ref{tab:gpg_edit-key_options}. 

\begin{table}[htb]
  \centering
  \footnotesize
  \begin{tabular}{|l|p{8cm}|}
    \hline
    \textbf{Opzione}&\textbf{Significato}\\
    \hline
    \hline
    \texttt{fpr}  & Stampa la \textit{fingerprint} della chiave.\\ 
    \texttt{help} & Stampa un elenco dei comandi disponibili.\\  
    \texttt{sign} & Firma la chiave con la propria.\\ 
    \texttt{list} & Ristampa i dati della chiave.\\ 
    \texttt{trust}& Imposta un livello di fiducia per la chiave.\\ 
    \texttt{save} & Salve le modifiche fatte alla chiave ed esce.\\ 
    \texttt{quit} & Esce dalla riga di comando (chiede di salvare
                    eventuali modifiche).\\ 
%    \texttt{-{}-}& .\\ 
    \hline
  \end{tabular}
  \caption{Principali comandi interni dell'opzione \texttt{-{}-edit-key} di
    \texttt{gpg}.}
\label{tab:gpg_edit-key_options}
\end{table}

Come detto in generale scaricare la chiave di un corrispondente non è
sufficiente a considerarla valida, perché potremmo essere soggetti a un
attacco di \itindex{man-in-the-middle} \textit{man-in-the-middle}, ed occorre
quindi verificarne l'autenticità.  Come accennato se si è avuto un incontro
diretto il modo più semplice è quello di scambiarsi la \textit{fingerprint}
della chiave e verificare in seguito se essa corrisponde a quella della chiave
che si è scaricato, per questo basterà usare il comando \texttt{fpr}:
\begin{Console}
gpg> \textbf{fpr}
pub   1024D/2A972F9D 2000-08-14 Simone Piccardi (Truelite SrL) <piccardi@truelite.it>
 Primary key fingerprint: 8548 9BA4 FE34 A74B 4504  E8FA C12D C806 2A97 2F9D
\end{Console}
e con il risultato si potrà effettuare la verifica. 

Se la chiave risulta valida si potrà decidere di firmarla con il comando
\texttt{sign}, il comando ci chiederà se si intendono firmare tutti gli
\textit{User ID} ad essa associati e chiederà ulteriore conferma; dopo di che
verrà chiesta la passphrase per la propria chiave per poter apporre la
firma. Si avrà pertanto qualcosa del tipo:
\begin{Console}
gpg> \textbf{sign}
Really sign all user IDs? (y/N) \textbf{y}
User ID "Simone Piccardi <piccardi@fi.infn.it>" is revoked.  Unable to sign.

pub  1024D/2A972F9D  created: 2000-08-14  expires: never       usage: SC  
                     trust: unknown       validity: unknown
sub  4096g/68B0E6EC  created: 2000-08-14  expires: never       usage: E   

     Simone Piccardi (Truelite SrL) <piccardi@truelite.it>
     Simone Piccardi <piccardi@firenze.linux.it>
     Simone Piccardi (AsSoLi) <piccardi@softwarelibero.it>
     Simone Piccardi (AsSoLi) <piccardi@softwarelibero.org>

Are you sure that you want to sign this key with your
key "Truelite Srl (Truelite) <info@trl.tl>" (58AF19F7)

Really sign? (y/N) \textbf{y}

You need a passphrase to unlock the secret key for
user: "Truelite Srl (Truelite) <info@trl.tl>"
2048-bit RSA key, ID 58AF19F7, created 2011-07-07

Enter passphrase: 

gpg> quit
Save changes? (y/N) \textbf{y}
\end{Console}
e si noti come all'uscita del programma venga richiesto il salvataggio dei
cambiamenti, infatti tutte le operazioni eseguite non verranno riportate nel
proprio \textit{keyring} a mano di non eseguire esplicitamente un salvataggio,
cosa che esser fatta eseguendo subito il comando \texttt{save}, o uscendo
dalla riga di comando con \texttt{quit}.

Se se a questo punto si ripeterà la verifica o l'accesso alla gestione della
chiave questa volta si otterrà qualcosa del tipo:
\begin{Console}
gpg> \textbf{list}
pub  1024D/2A972F9D  created: 2000-08-14  expires: never       usage: SC  
                     trust: unknown       validity: full
sub  4096g/68B0E6EC  created: 2000-08-14  expires: never       usage: E   
[  full  ] (1). Simone Piccardi (Truelite SrL) <piccardi@truelite.it>
[ revoked] (2)  Simone Piccardi <piccardi@fi.infn.it>
[  full  ] (3)  Simone Piccardi <piccardi@firenze.linux.it>
[  full  ] (4)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.it>
[  full  ] (5)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.org>
\end{Console}

Firmare una chiave significa soltanto che si è sicuri che questa appartenga al
corrispondente perché lo si è verificato in una maniera che ci soddisfa, ma
questo non ha necessariamente nessuna conseguenza sul quanto ci si possa
fidare delle verifiche fatte dal corrispondente, perché questi potrebbe essere
sia un paranoico della sicurezza che effettua verifiche estremamente pignole,
che un utilizzatore occasionale che firma qualunque chiave gli capiti di
scaricare senza neanche aver troppo chiaro quello che fa.

Per questo come si può notare nonostante la chiave risulti pienamente valida,
dato che la si è firmata, il livello di fiducia resta indefinito, e resterà
tale fintanto che non si decide di impostarne uno con il comando
\texttt{trust}. Eseguendolo ci verrà chiesto un valore numerico che lo indichi
in un intervallo da 1 a 5, con relativa spiegazione dei livelli che vanno dal
non so (il valore assegnato alle chiavi appena scaricate) alla fiducia
assoluta (che però si usa solo per la propria chiave). Un possibile esempio
potrebbe essere allora:
\begin{Console}
gpg> \textbf{trust}
pub  1024D/2A972F9D  created: 2000-08-14  expires: never       usage: SC  
                     trust: unknown       validity: full
sub  4096g/68B0E6EC  created: 2000-08-14  expires: never       usage: E   
[  full  ] (1). Simone Piccardi (Truelite SrL) <piccardi@truelite.it>
[ revoked] (2)  Simone Piccardi <piccardi@fi.infn.it>
[  full  ] (3)  Simone Piccardi <piccardi@firenze.linux.it>
[  full  ] (4)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.it>
[  full  ] (5)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.org>

Please decide how far you trust this user to correctly verify other users' keys
(by looking at passports, checking fingerprints from different sources, etc.)

  1 = I don't know or won't say
  2 = I do NOT trust
  3 = I trust marginally
  4 = I trust fully
  5 = I trust ultimately
  m = back to the main menu

Your decision? \textbf{4}

pub  1024D/2A972F9D  created: 2000-08-14  expires: never       usage: SC  
                     trust: full          validity: full
sub  4096g/68B0E6EC  created: 2000-08-14  expires: never       usage: E   
[  full  ] (1). Simone Piccardi (Truelite SrL) <piccardi@truelite.it>
[ revoked] (2)  Simone Piccardi <piccardi@fi.infn.it>
[  full  ] (3)  Simone Piccardi <piccardi@firenze.linux.it>
[  full  ] (4)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.it>
[  full  ] (5)  Simone Piccardi (AsSoLi) <piccardi@softwarelibero.org>
Please note that the shown key validity is not necessarily correct
unless you restart the program.
\end{Console}

L'assegnazione di un livello di fiducia ad una chiave consente di indicare
quanto ci si fida delle altre chiavi firmate da quella chiave, ad esempio
dando piena fiducia ad una chiave come fatto in precedenza diventeranno
completamente valide le altre chiavi da essa firmate, così se prima della
assegnazione del livello di fiducia per una altra chiave firmata dalla prima
si aveva qualcosa del tipo:
\begin{Console}
$ \textbf{gpg --edit-key 26257B68}
gpg (GnuPG) 1.4.11; Copyright (C) 2010 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


pub  1024D/26257B68  created: 1999-09-23  expires: never       usage: SC  
                     trust: unknown       validity: unknown
sub  2048g/56EC3680  created: 1999-09-23  expires: never       usage: E   
[ unknown] (1). Christian Surchi <christian@truelite.it>
[ revoked] (2)  Christian Surchi <csurchi@mclink.it>
...
\end{Console}
%$
in cui la validità o meno della chiave era \texttt{unknown}, dopo ci si
troverà con:
\begin{Console}
$ \textbf{gpg --edit-key 26257B68}
gpg (GnuPG) 1.4.11; Copyright (C) 2010 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.


pub  1024D/26257B68  created: 1999-09-23  expires: never       usage: SC  
                     trust: unknown       validity: full
sub  2048g/56EC3680  created: 1999-09-23  expires: never       usage: E   
[ unknown] (1). Christian Surchi <christian@truelite.it>
[ revoked] (2)  Christian Surchi <csurchi@mclink.it>
...
\end{Console}
%$
e la validità adesso è \texttt{full}.

La ragnatela può allora costituirsi assegnando dei livelli di fiducia alle
varie chiavi del proprio portachiavi, e questi saranno impiegati per stabilire
la validità o meno delle chiavi da esse firmate. L'impostazione di default è
che vengono considerate valide le chiavi firmata da una chiave per il quale si
è assegnato una fiducia completa (\textit{full trust}) o da almeno tre chiavi
di cui si ha fiducia marginale (\textit{marginal trust}), ma questi valori
possono essere modificati. 

La spiegazione dei vari dettagli della gestione del \textit{web of trust} di
\texttt{gpg} va oltre lo scopo di queste dispense, e per una trattazione
approfondita si rimanda alla documentazione completa presente nella pagina di
manuale del comando.

\else
\relax
%%
%% FINE: Sezione specifica da non includere in AGL
%%
\fi



% LocalWords:  TLS SSL PKI public key infrastructure the middle authority PEM
% LocalWords:  certification secure socket layer corporation TCP draft hash and
% LocalWords:  transport security RFC openssl  challenge response SSH TTP third
% LocalWords:  trusted of PGP GPG digital identity OpenCA guard pretty good DER
% LocalWords:  PKCS Diffie Hellman LDAP organization organizational unit common
% LocalWords:  department name tab version number CRL signature algorithm info
% LocalWords:  issuer validity subject extensions cert type MIME object Philip
% LocalWords:  signing client sez patch revocation list libssl libtls locality
% LocalWords:  Zimmerman Truelite DSA stunnel https STARTLS SMTP RSA Request sh
% LocalWords:  CSR UDP Datagram DTLS descriptor bootstrap conf ini Windows yes
% LocalWords:  chroot pathname setuid setgid CAfile CRLfile verify accept debug
% LocalWords:  connect facility priority syslog compression zlib rle pid PID pl
% LocalWords:  CApath CRLpath sslVersion all tinyca wrapper crl to IT ST FI Srl
% LocalWords:  dsa pkey genpkey genrsa gendsa rsa req OpenSSL Perl var ps fd
% LocalWords:  shell wipe days filename making using configuration from is it
% LocalWords:  generating writing new pass phrase verifying about asked you OU
% LocalWords:  information that will incorporated into your request what CN May
% LocalWords:  called distinguished DN There quite few fields but can leave for
% LocalWords:  blank there value id field left letter company section address
% LocalWords:  demoCA text please following attributes sent with an FQDN fully
% LocalWords:  qualified domain OpenLDAP hostname requests certified commit ls
% LocalWords:  write entries updated signed umask wildcard subjectAltName slapd
% LocalWords:  GnuTLS certs root CAcert org SSLv TLSv newca parker Before GMT
% LocalWords:  not after rsaEncryption newreq CertAuth AU eg pem noout VPN sign
% LocalWords:  modulus matches subjects as follows countryName PRINTABLE until
% LocalWords:  stateOrProvinceName localityName organizationName commonName Aug
% LocalWords:  emailAddress newcert newkey read URL DNS total stdin passin at
% LocalWords:  passout encoding rules enhanced BEGIN identifier sha comment
% LocalWords:  WithRSAEncryption generated long env Jun basic Constraints DES
% LocalWords:  validation policies virtual host based shred cnf SSLEAY Repeat
% LocalWords:  CONFIG config CADAYS truelite details TRUE index txt Squeeze
% LocalWords:  organizationalUnitName bits min usr objsign nsCertType dotted
% LocalWords:  decimal gnulinux keyserver backdoor keypair OpenPGP gpg gen We
% LocalWords:  fingerprint gnupg home passphrase GnuPG Foundation Inc This if
% LocalWords:  change redistribute extent permitted law select kind want may
% LocalWords:  only selection keys between keysize specify how should valid
% LocalWords:  does expire expires weeks months years this correct need form
% LocalWords:  identify constructs protect ssh lot bytes perform other move
% LocalWords:  action keyboard utilize disks during generation gives better
% LocalWords:  generator gain enough entropy available work give collect has
% LocalWords:  trustdb created marked ultimately checking marginal needed he
% LocalWords:  depth keyring revoke reason specified been compromised longer
% LocalWords:  superseded used here decision description empty line unlock OS
% LocalWords:  armored forced which hide away gets access make unusable just
% LocalWords:  smart print store become unreadable have caution system might
% LocalWords:  machine others armor send recv sending hkp requesting scheme
% LocalWords:  imported processed ldap mailto requested selected cancel local
% LocalWords:  probably archive Aautomatic untrusted recipient encrypt detach
% LocalWords:  assurance belongs named primary subkey certain person main say
% LocalWords:  really doing answer next question anyway detached decrypt edit
% LocalWords:  automatic encrypted never usage unknown revoked save quit des
% LocalWords:  unable sure changes correctly looking passports fingerprints
% LocalWords:  different sources marginally back shown necessarily unless Pty
% LocalWords:  restart program RedHat CentOS Widgits Ltd DigiNotar WARRANTY
% LocalWords:  Elgamal Heinrich Heine Der Dichter uid sec asc BLOCK Surchi
% LocalWords:  Fri Jul CEST fpr

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "sicurezza"
%%% End: 

