Inizio Capitolo

GnuPG


Chi rinuncia alla libertà per raggiungere la sicurezza non merita né la libertà né la sicurezza. [Benjamin Franklin]

Garantirsi la necessaria privacy abbinando GnuPG a Mutt

Mutt è in grado di gestire messaggi spediti e ricevuti che sono firmati e/o criptati con strumenti di firma digitale a doppia chiave asimmetrica (definiti anche a chiave pubblica).

In questo capitolo illustriamo come inviare messaggi con firma digitale, in modo da garantire maggiore sicurezza circa l'autenticità della nostra identità come mittenti e la non contraffazione del messaggio da noi scritto.

Vedremo anche come sia possibile inviare messaggi criptati, ciò al fine di garantire la nostra esigenza di privacy relativamente ai contenuti spediti attraverso la rete.

Altresì scopriremo come sia possibile per Mutt leggere messaggi che abbiamo ricevuto da persone che hanno, a loro volta, firmato e/o criptato i propri messaggi.

Mutt non effettua direttamente le operazioni di firma digitale e di cifratura ma utilizza un software apposito, interfacciandosi con esso attraverso il settaggio di alcune variabili di configurazione e la messa a disposizione di specifici comandi e menu.

In questa guida vedremo come utilizzare, in abbinata con Mutt, GnuPG che è il più famoso e diffuso software open source di firma digitale a doppia chiave asimmetrica.

GnuPG è conforme allo standard OpenPG (RFC 2440), ed è in grado di collaborare con l'altrettanto famoso PGP che non è tuttavia gratuito (ma rilascia il codice sorgente).

Prima di illustrare come firmare e/o criptare un messaggio spedito, oppure per verificare la firma e/o decriptare un messaggio ricevuto, trattiamo, seppur in modo breve e non esaustivo, le motivazioni per l'utilizzo di un software di firma digitale e la teoria e funzionamento dei sistemi di firma digitale a doppia chiave asimmetrica.

Conoscere un pò di teoria ci aiuterà ad utilizzare meglio il nostro sistema di firma e criptazione.

Per gli approfondimenti suggerisco la lettura del Manuale GNU sulla privacy.

Riassumendo, in questo capitolo vedremo:

  1. Le motivazioni per l'adozione di un software di firma digitale per le nostre email.
  2. La teoria e il funzionamento dei sistemi di firma digitale e chiave pubblica.
  3. Il funzionamento di GnuPG.
  4. La firma e/o la criptazione dei messaggi attraverso Mutt/GnuPG.
  5. La gestione di messaggi ricevuti firmati e/o criptati con GnuPG (o PGP).
  6. La personalizzazione del PGP Menu.
  7. La gestione del vecchio formato inline.
  8. La configurazione del .muttrc per GnuPG.

Motivazione all'utilizzo di mail firmate e/o criptate


Perchè utilizzare firma digitale e criptazione per le email?

Potremmo aver bisogno di riservatezza.
In tal caso non è opportuno che il messaggio di posta elettronica transiti in chiaro attraverso la rete.
Per garantire la segretezza (la confidenzialità) del contenuto del messaggio possiamo criptarlo.
Facendo un parallelo con la posta cartacea: spesso inviamo cartoline, ma a volte spediamo lettere in busta!

Potrebbe essere necessario avere certezza dell'identità di chi ci scrive, oppure il destinatario deve esserlo della nostra.
In questa evenienza un messaggio privo di una firma digitale può lasciarci nel dubbio.
Firmando digitalmente il messaggio assicuriamo l'autenticità del mittente.
Sempre ricorrendo al confronto con le comunicazioni cartacee, una lettera scritta a mano o perlomeno firmata in calce ci garantisce, se conosciamo la scrittura del suo autore, sulla sua autenticità, diversamente da una lettera scritta a macchina e senza firma a penna in calce.

Potrebbe essere per noi importante l'integrità ovvero sapere che il contenuto scambiato in rete non potrà essere modificato da altri durante il transito dal mittente al destinatario.
Con la firma digitale del messaggio otteniamo anche la garanzia di non modifica del contenuto del messaggio.
Nel caso di una lettera, quando abbiamo questa necessità, ci assicuriamo di chiuderla bene e, se amanti della tradizione, possiamo anche apporre un bel timbro in ceralacca.

Concrete e frequenti, quindi, le esigenze che dovrebbero spingerci ad utilizzare un software di firma digitale. Ma non dobbiamo temere complicazioni adottandolo, poichè esso lavora in modo trasparente all'utente e non complica le normali modalità di utilizzo della posta elettronica (perlomeno GnuPG con Mutt!).

L'autore di PGP, Phil Zimmermann, scrisse un articolo sul perchè utilizzare il suo software:
Why do you need PGP?


Perchè l'utilizzo dei sistemi di firma digitale e criptazione è poco diffuso?

Forse grazie al fatto che Mutt è un mail client molto geeky, l'utilizzo di GnuPG da parte dei mutter è generalmente frequente.

Purtroppo non possiamo dire lo stesso per il resto del mondo. Quando qualcuno si siede al PC ed inizia ad utilizzare la rete internet ed i suoi servizi, tipicamente sembra perdere ogni barlume di razionalità riguardo ai temi della privacy.

Solo il vile denaro riesce a mantenere viva la coscienza sui pericoli della comunicazione su reti pubbliche.

Per il resto nessuna remora: che si tratti di conversazioni tra amanti o di navigazione nei bassifondi pornografici di internet, tutto si svolge fidando del fatto che nel mare magnum dei bit trasmessi in rete i propri, equivalenti ad una goccia nell'oceano, finiscano per essere irriconoscibili.

All'incoscienza si aggiunge l'ignoranza: pochi conoscono l'esistenza dei sistemi disponibili per garantire maggiore sicurezza alle proprie comunicazioni e, quando li conoscono, di norma li giudicano complessi da utilizzare.

Per chi legge l'inglese è interessante questo documento sulle motivazioni limitanti l'utilizzo di PGP: Why Johnny can't encrypt.

Un altro studio interessante è stato effettuato dalla Carnegie Mellon University, mediante un case study sulla usabilità del software (PGP) per la sicurezza: Usability of Security: A Case Study.


^top

Teoria e Funzionamento sistema di firma a doppia chiave asimmetrica


I sistemi di firma e criptazione utilizzati maggiormente in internet sono a chiave pubblica (anche definiti a doppia chiave asimmetrica). Perchè si sono affermati rispetto ai sistemi di firma simmetrica?

Chiavi privata e pubblica I vantaggi di un tale sistema sono evidenti non appena se ne conosce il funzionamento. Vediamolo in sintesi.

Tutto si basa sulla creazione di due chiavi, una definita privata ed una pubblica.

Per la descrizione della funzione delle due chiavi attingiamo al Manuale GNU sulla privacy.

In caso di criptazione del messaggio il funzionamento è il seguente:

"Chiave pubblica e privata hanno ognuna uno specifico ruolo nella codifica e decodifica di documenti.
Una chiave pubblica può essere vista come una cassaforte aperta.
Quando un corrispondente cripta un documento utilizzando una chiave pubblica, quel documento viene messo nella cassaforte, la cassaforte viene chiusa ed il lucchetto a combinazione fatto girare diverse volte.
La chiave privata corrispondente è la combinazione che può riaprire la cassaforte e recuperare il documento.
In altre parole, solo la persona che detiene la chiave privata può recuperare un documento cifrato utilizzando la chiave pubblica corrispondente."

In caso di firma digitale del messaggio la coppia di chiavi lavora invece così:

"Una firma digitale certifica e appone la data ad un documento. Se il documento viene successivamente modificato in qualsiasi modo, una verifica della firma fallirà.
Una firma digitale può servire allo stesso scopo per il quale si utilizza una firma fatta a mano con l'ulteriore beneficio di essere a prova di manomissione.
La creazione e la verifica di firme utilizzano la coppia di chiavi pubblica/privata in modo differente da quanto fanno le operazioni di cifratura e decifratura.
Una firma è fatta utilizzando la chiave privata di colui che firma.
La firma viene verificata utilizzando la corrispondente chiave pubblica.
Una conseguenza dell'utilizzo di firme digitali consiste nel fatto che è difficile negare di aver fatto una firma digitale in quanto ciò implicherebbe che la propria chiave privata era stata compromessa."

Firma e criptazione

Credo appaia con chiarezza la differenza con i sistemi che utilizzano chiavi simmetriche, ove il sistema utilizza la stessa chiave per qualsiasi operazione (firme e verifica firma, criptazione e decriptazione). Applicando questo sistema ai messaggi email, si avrebbe necessità di un gran numero di chiavi (una per ogni relazione che teniamo) e si avrebbe il problema di come consegnare la chiave al destinatario in modo sicuro.

Differenza tra chiave convenzionale e chiave pubblica

Con il sistema a doppia chiave asimmetrica si gestiscono efficacemente sia il tema della distribuzione, sia quello della numerosità delle chiavi: ciascun utente diffonde la propria chiave pubblica che potrà essere utilizzata da quanti vorranno scrivergli in modo sicuro.

Confronto tra firma simmetrica e asimmetrica

Per la diffusione della propria chiave si possono utilizzare i keyserver, ovvero server che ospitano le chiavi pubbliche. Tali server possono essere interrogati online dal programma di firma/criptazione quando si deve inviare un messaggio e non si dispone della chiave pubblica del destinatario.

I keyserver sparsi per la rete provvedono periodicamente a sincronizzarsi fra loro; pertanto è sufficiente inviare la propria chiave pubblica ad un solo keyserver per garantirsi la sua diffusione in rete.

La propria chiave pubblica può essere diffusa anche pubblicandola sul proprio sito internet, allegandola ai propri messaggi email, ecc...

Alla chiave privata, l'altra componente, il cuore del sistema, va garantita la massima sicurezza, tenendola al sicuro da estranei.


Qual'è l'anello debole del sistema a doppia chiave asimmetrica?

Il punto critico del sistema a doppia firma asimmetrica è connesso al fatto che dovrei avere certezza che la chiave pubblica di una persona sia effettivamente la sua.

Per assegnare ad una chiave pubblica un certo livello di confidenza sulla sua autenticità, un altro utente che se ne fa garante (dell'autenticità) può firmare la chiave, che diventa quindi una chiave certificata.

Più una chiave è stata firmata da altri utenti e maggiore sarà elevato il suo grado di autenticità. Si parla di rete della fiducia (in inglese web of trust).

Schematizzazione del Web of Trust

Quando si incontrano due o più utenti che usano lo stesso sistema di firma e criptazione spesso si approfitta per effettuare questo mutuo riconoscimento della autenticità della propria chiave pubblica (si parla di key signing party, per i quali non può mancare l'apposita guida: GnuPG Keysigning Party HOWTO).

Poichè non è sempre facile incontrarsi, è possibile firmare una chiave pubblica verificando un particolare codice di controllo della chiave definito impronta digitale (fingerprint), che il suo legittimo possessore mi ha fornito in modo sicuro (di persona, al telefono, ...).

Nei sistemi in cui la firma digitale deve assumere valore legale (equivalente alla firma autografa) entra in gioco una autorità terza che effettua il lavoro di rilascio e certificazione delle firme (Certification Authority). Lo standard utilizzato è il sistema con certificati X.509 allegati in formato S/MIME.

Abbiamo illustrato motivazioni, vantaggi, limiti e principi di funzionamento dei sistemi a doppia chiave asimmetrica. Vediamo ora come lavora GnuPG per eseguire le operazioni di firma e quelle di criptazione.


^top

Come GnuPG effettua le operazioni di firma e criptazione



Come funziona la firma di un messaggio con GnuPG

Il mittente:
  1. Scrive il messaggio.
  2. GnuPG crea un codice di controllo (hash code) del messaggio.
  3. GnuPG cripta il codice di controllo utilizzando la chiave privata del mittente (si crea la cosiddetta firma digitale del messaggio).
  4. Il codice di controllo criptato (firma digitale) viene allegato al messaggio.
Firma di un messaggio da parte di GnuPG

Il destinatario che verifica il messaggio:
  1. GnuPG decripta il codice di controllo allegato utilizzando la chiave pubblica del mittente.
  2. GnuPG rigenera contemporaneamente un codice di controllo del messaggio ricevuto.
  3. GnuPG confronta il codice generato con il codice decriptato che era allegato al messaggio.
  4. Se i codici (hash code) si equivalgono la verifica è superata e GnuPG dichiara autentico il messaggio.
Verifica della firma di un messaggio da parte di GnuPG

Tale processo consente di creare una firma ogni volta diversa, perchè basata anche sul contenuto del messaggio firmato: il codice di controllo viene infatti generato eseguendo un algoritmo sul corpo del messaggio. Per questo mediante la firma del messaggio garantiamo la sua autenticità ed anche la sua integrità.


Come funziona la criptazione di un messaggio con GnuPG

Il mittente
  1. Scrive il messaggio
  2. GnuPG genera una chiave di sessione (session key), valida solo per il messaggio da criptare.
  3. GnuPG cripta il messaggio applicando alla chiave di sessione l'algoritmo di criptazione.
  4. GnuPG cripta la chiave di sessione utilizzando la chiave pubblica del destinatario e la inserisce in testa al messaggio criptato.
Criptazione di un messaggio da parte di GnuPG

Il destinatario
  1. GnuPG decripta la chiave di sessione utilizzando la propria chiave privata.
  2. GnuPG utilizza la chiave di sessione per decriptare il messaggio.
Decriptazione di un messaggio da parte di GnuPG

Per come funziona il processo, il messaggio che abbiamo criptato e spedito non potrà essere decriptato nemmeno da noi. Vedremo che possiamo tuttavia configurare l'abbinata Mutt-GnuPG affinchè ci venga consentito di rileggere il contenuto del messaggio criptato che abbiamo spedito, quando ne salviamo una copia nella mailbox predefinita per i messaggi inviati.

Ugualmente penso sia chiaro che la sola criptazione del messaggio non garantisce sull'autenticità del messaggio. Per questo possiamo firmare ed anche criptare il messaggio.


Come funziona la firma e criptazione di un messaggio con GnuPG

I due processi sopra descritti vengono eseguiti in successione. All'invio del messaggio, viene prima eseguito il processo di firma e poi quella di criptazione. Alla ricezione del messaggio prima si decripta e poi si verifica la firma.


La firma del messaggio è parte del messaggio o è separata?

La modalità di apposizione della firma al messaggio nel tempo si è evoluta.

Inizialmente, con le prime versioni di PGP, la firma di un messaggio veniva inclusa nel corpo del messaggio. Era la cosiddetta firma in formato tradizionale o inline.

Utilizzando tale modalità il corpo del messaggio viene "sporcato" dalla presenza dei dati di firma, come possiamo vedere con questo esempio:

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Il testo del messaggio è questo, come si vede il resto è
costituito dalla firma GnuPG.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (GNU/Linux)

iD8DBQFDDA1eN5XoxaHnMrsRAsOPAKCBrt/YQuI8/rSD3rfQpYxJZowFPACdEYS5
VoXLQNhyvirGLwvIZjuJLHY=
=xGk+
-----END PGP SIGNATURE-----

Il primo programmatore a porsi il problema di separare il corpo del messaggio dalla firma è stato Michael Elkins, il creatore di Mutt.

Nella versione 1.4, Mutt introdusse infatti un escamotage, mediante il quale la firma veniva allegata in un particolare formato MIME (application/pgp), specificando tuttavia di essere un messaggio inline (content-disposition: inline).

Tale modalità di gestione, che non ha mai assunto il ruolo di standard, è evoluta successivamente in uno standard internet, sempre curato da Michael Elkins, definito PGP/MIME, in base al quale la firma viene separata dal corpo del messaggio, allegandola come componente MIME in formato, appunto, PGP/MIME.

I formati MIME introdotti dallo standard sono:

Mutt adotta tale standard dalla versione 1.5 e molti altri client di posta sono oggi in grado di utilizzarlo.

PGP/MIME ha successivamente subito una ulteriore evoluzione per mantenersi adeguato allo standard OpenPGP (a cui GnuPG si conforma).

Per quanti vogliono leggere, in inglese, i due documenti:
RFC2015: MIME Security with Pretty Good Privacy (PGP) - ottobre 1996
RFC3156: MIME Security with OpenPGP - agosto 2001

I sistemi che invece assegnano alle Autorità di certificazione il compito di rilasciare e garantire l'autenticità delle firme utilizzano un formato diverso, chiamato S/MIME, che non è tuttavia progettato per garantire interoperabilità con PGP/MIME (S/MIME è divenuto uno standard IETF alla sua terza versione, nel luglio 1999).

Per un confronto tra OpenPGP e S/MIME:
S/MIME and OpenPGP

Aver separato corpo del messaggio e firma dello stesso garantisce che un utente che non utilizza GnuPG (o PGP) o che utilizza un client di posta che non interagisce con esso potrà comunque leggere il messaggio.

Il minimo richiesto è che il client sia capace di gestire i messaggi MIME e, nello specifico, PGP/MIME. Purtroppo sappiamo che c'è chi vive in un mondo tutto suo: il noto programma Guardafuori Espresso, ad esempio, non è in grado di fare nemmeno questo.

L'evoluzione continua delle funzionalità dei programmi può rendere velocemente obsoleta qualsiasi critica circa i limiti di questo o quel sotware. Per verificare lo stato dell'arte in materia, possiamo far riferimento a queste due pagine:
Quali programmi di posta elettronica è possibile usare con GnuPG
The MUA Support Matrix
Mail Reader with PGP/MIME Support

Dopo aver illustrato, seppur per grandi linee, come lavora GnuPG, siamo pronti per vedere con quale semplicità è in grado di collaborare con Mutt.


^top

Scrivere un messaggio e trattarlo con GnuPG


Come inviare un messaggio firmato


Per inviare con Mutt un messaggio firmato da GnuPG
1. scriviamo normalmente il nostro messaggio

2. arrivati al compose menu, premiamo p

3. scegliamo l'azione di firma premendo s
(e)ncrypt, (s)ign, sign (a)s, (b)oth, (i)nline, or (c)lear

4. premiamo y per inviare

5. inseriamo la password di GnuPG e premiamo INVIO

Notiamo che dopo aver scelto di firmare, l'header PGP viene valorizzato così:
PGP: Firma (PGP/MIME)
firma come: 0xC9B94521

(0xC9B94521 è l'ID della chiave pubblica utilizzata; in questo caso il mio)

Le opzioni disponibili includono anche (i)nline solo se la versione di Mutt contiene la pgp-menu-traditional patch di Dale Woolridge (che mi risulta inclusa nelle versioni stable e development il 15 aprile 2003).


TIP: Come pulire la memoria dalla password GnuPG

Quando abbiamo fatto un errore nella digitazione della password, è utile poter azzerare la memoria della password per poterla ridigitare senza dover aspettare che scada il tempo di mantenimento in memoria.

Per questo possiamo ricorrere alla funzione forget-passphrase eseguibile digitando:
CTRL f (forget-passphrase)

La funzione è disponibile in
La funzione serve solo se non abbiamo abbiamo impostato a zero la variabile pgp_timeout, che definisce per quanti secondi la password rimane memorizzata nella cache (il valore di default è 300 secondi).


Come inviare un messaggio criptato


Per inviare con Mutt un messaggio criptato da GnuPG
1. scriviamo normalmente il nostro messaggio

2. arrivati al compose menu, premiamo p

3. scegliamo l'azione di criptazione premendo e
(e)ncrypt, (s)ign, sign (a)s, (b)oth, (i)nline, or (c)lear

4. premiamo y per inviare

6. premiamo INVIO quando richiesto (al termine della criptazione)

Notiamo che dopo aver scelto di firmare, l'header PGP viene valorizzato così:
PGP: Crittografa (PGP/MIME)


Il PGP Menu per selezionare la chiave con cui criptare


Mutt sceglie da solo la chiave pubblica per criptare quando, nel nostro portachiavi (keyring), ne trova una il cui userid corrisponde ad uno dei destinatari.

Quando non è evidente quale chiave deve essere utilizzata per criptare il messaggio da inviare ad un certo destinatario, Mutt apre invece il PGP Menu, che elenca le chiavi pubbliche utilizzabili.

Il momento in cui si apre il PGP Menu è dopo che si è premuto y (siamo sempre nel Compose Menu) per spedire il messaggio che si è chiesto di criptare.

Per indicare la chiave da utilizzare:
1. la si seleziona dall'elenco

2. si preme Invio.

Scelta la chiave, Mutt:

TIP: Come uscire dal PGP Menu quando non si è trovata una chiave

Potrebbe accadere che non si disponga di una chiave pubblica per il nostro destinatario.

In questo caso dobbiamo uscire dal PGP Menu e, tornati al compose menu, annullare la richiesta di criptare il messaggio da spedire.

Per far questo dobbiamo:
1. premere q (quit)
 
2. premere CTRL g
 
3. premere p
 
4. premere c (clear) 

Una volta nel PGP Menu abbiamo a disposizione anche due comandi che possiamo eseguire sulla chiave che abbiamo selezionato dall'elenco:

premendo % (view-name) si visualizza lo userid della chiave
premendo c (verify-key) si effettua la verifica della chiave

TIP: Come vincolare la scelta della chiave per un indirizzo email

In alcuni casi, potrebbe essere utile indicare a Mutt quale chiave pubblica deve automaticamente e forzatamente utilizzare, nel caso gli si chieda di criptare (tramite GnuPG) un messaggio da inviare ad un certo indirizzo email.

Per questa esigenza abbiamo a disposizione un hook, in precedenza non trattato. Si tratta del pgp-hook.

Possibili motivi di utilizzo del pgp-hook:

La sintassi del pgp-hook (pgp-hook pattern keyid) prevede l'indicazione di un pattern che, qualora verificato, forza Mutt ad utilizzare il keyid indicato dopo il pattern.

Tipicamente inseriremo un pattern per identificare l'indirizzo email del destinatario. Il keyid è l'ID della chiave pubblica.

Un rapido modo per farsi elencare da GnuPG il o i keyid associati ad un certo indirizzo email è di digitare in una finestra di terminale:

$ gpg --list-sigs | grep [email protected]


Un semplice esempio di pgp-hook per il .muttrc:
pgp-hook [email protected] 0x12AB34CD

Come allegare ad un messaggio una chiave pubblica


Per inviare un messaggio allegando una chiave pubblica
1. scriviamo normalmente il nostro messaggio

2. arrivati al compose menu, premiamo ESC k per allegare la chiave

3. Mutt ci chiede nella status line il key ID

4. premiamo INVIO per accedere all'elenco delle chiavi pubbliche
   contenute nel nostro portafoglio di chiavi (keyring)

5. selezioniamo la chiave desiderata e premiamo INVIO

4. premiamo y per inviare

Notiamo che dopo avere allegato la chiave nel compose menu compare un ulteriore allegato in formato application/pgp-keys (uno dei tre tipi di allegati previsti dallo standard PGP/MIME).

La funzione ESC k (mail-key), è disponibile anche quando siamo

Eseguendo il comando da queste schermate, ai passi precedenti si devono aggiungere, in testa, quelli classici di definizione del destinatario del messaggio e di indicazione dell'oggetto del messaggio.


TIP: Inserire utili informazioni negli header del messaggio

Utilizzando GnuPG, possiamo personalizzare gli header dei messaggi che spediamo, siano o no essi firmati e/o criptati, inserendo utili informazioni per i destinatari.

Comunemente si inseriscono:

Rimando al paragrafo che illustra il settaggio degli header del messaggio per un esempio.



^top

Leggere un messaggio trattato con GnuPG


Come riconoscere un messaggio trattato con GnuPG

Nel capitolo introduttivo abbiamo illustrato come Mutt ci fornisca nell'indice dei messaggi (index menu), tramite i cosiddetti status flag, alcune utili informazioni sul messaggio già prima di visualizzarlo nel pager. Avevamo allora elencato solo i principali status flag.

Vediamo ora gli status flag specificamente riferiti a GnuPG
K il messaggio contiene una chiave pubblica
P il messaggio è criptato
s il messaggio è firmato
S il messaggio è firmato e la firma verificata

Come salvare nel portachiavi una chiave allegata ad un messaggio

Mediante la funzione CTRL-k (extract-key), possiamo estrarre la chiave pubblica ricevuta in allegato in un messaggio ed inserirla nel nostro portachiavi di chiavi pubbliche.

Il comando CTRL-k (extract-key), è disponibile in

Se eseguiamo questo comando dall'indice dei messaggi, possiamo selezionare (taggare) più messaggi contenenti chiavi pubbliche (segnalati mediante lo status flag K), estraendo così più chiavi in una volta sola.


Come leggere un messaggio firmato


Per leggere con Mutt un messaggio firmato da GnuPG

In realtà non c'è nessuna spiegazione da fornire, poichè di default Mutt provvede automaticamente a verificare la firma del messaggio, nel momento in cui entriamo in lettura nel pager.

Potremo riscontrare l'avvenuta verifica della firma, tramite il messaggio visualizzato da Mutt nella input line (Firma PGP verificata con successo).

Oltre a ciò noteremo come, dopo gli header del messaggio e prima del testo, venga visualizzato l'output prodotto da GnuPG che, nel caso dell'attività di verifica della firma, sarà simile all'esempio seguente:

[-- Segue l'output di PGP (orario attuale: ven 29 set 2006 23:01:34 CEST) --]
gpg: Signature made ven 03 feb 2006 20:13:57 CET using DSA key ID C9B94521
gpg: Good signature from "Francesco Ciattaglia (aka Ataualpa) <[email protected]>"
[-- Fine dell'output di PGP --]

Infine il testo del messaggio sarà compreso tra questi due marcatori di testo:

[-- I seguenti dati sono firmati --]

testo mail firmata

[-- Fine dei dati firmati --]


Come leggere un messaggio ricevuto criptato


Per leggere con Mutt un messaggio criptato da GnuPG

In base a quanto illustrato poc'anzi, per decriptare un messaggio dobbiamo utilizzare la nostra chiave privata che è protetta da una password. Pertanto i passi da seguire sono:

1. selezioniamo il messaggio e premiamo INVIO

2. digitiamo nella input line la password della nostra chiave privata

3. premendo INVIO viene visualizzato il testo in chiaro

L'avvenuta decifrazione del messaggio ci viene evidenziata da Mutt nell'input line (PGP message successfully decrypted).

Gli stessi passi si seguono per leggere un messaggio che è sia criptato che firmato.

Come nel caso del messaggio firmato, dopo gli header del messaggio e prima del testo, viene visualizzato l'output prodotto da GnuPG che, nel caso dell'attività di decifratura e di verifica della firma sarà simile all'esempio seguente:

[-- Segue l'output di PGP (orario attuale: ven 29 set 2006 23:20:34 CEST) --]
gpg: encrypted with 2048-bit ELG-E key, ID CAF326C4, created 2005-12-31
"Francesco Ciattaglia (aka Ataualpa) <[email protected]>"
gpg: Signature made sab 04 feb 2006 10:52:18 CET using DSA key ID C9B94521
gpg: Good signature from "Francesco Ciattaglia (aka Ataualpa) <[email protected]>"
[-- Fine dell'output di PGP --]

Analogamente, il testo del messaggio sarà contornato dai seguenti marcatori:

[-- I seguenti dati sono cifrati con PGP/MIME --]

testo mail firmata e criptata

[-- Fine dei dati cifrati con PGP/MIME --]


Come copiare o spostare un messaggio criptato con contestuale decodifica

Se abbiamo necessità di fare una copia in chiaro o di archiviare in chiaro un messaggio che ci è arrivato criptato, Mutt ci mette a disposizione due funzioni che provvedono a decodificare il messaggio e, rispettivamente:
Premendo ESC C copia messaggio in un file o mailbox
Premendo ESC s salva messaggio spostandolo in un file o mailbox

Le funzioni di decodifica-copia/salva sono disponibili in:

Come leggere il testo dei messaggi criptati che abbiamo inviato


Prima soluzione

Sfruttiamo la capacità di GnuPG di crittografare il messaggio per più persone, ovvero di crittografarlo utilizzando più di una chiave pubblica. Nel caso specifico con la chiave pubblica del destinatario e anche con la nostra.

Se vogliamo applicare questa soluzione dobbiamo intervenire nel file di configurazione di GnuPG aggiungendo a ~/.gnupg/gpg.conf il comando:

encrypt-to <l'ID della propria chiave pubblica>

Questa soluzione imposta un comportamento di GnuPG che viene tenuto anche quando lo utilizziamo stand-alone e non in abbinata con Mutt, ovvero non solo nel caso di suo utilizzo per l'invio di posta.

Se utilizziamo GnuPG solo per la posta, nulla quaestio; altrimenti è opportuno prendere in considerazione la seguente ulteriore soluzione.


Seconda soluzione

Limitiamo la criptazione con più chiavi (quella del destinatario e la nostra) ai casi in cui GnuPG viene chiamato da Mutt.

A tal fine, dobbiamo personalizzare il settaggio delle seguenti variabili in .muttrc
Attraverso di esse si indica a Mutt come eseguire GnuPG quando deve, rispettivamente:
In entrambi i settaggi, dobbiamo includere l'opzione vista come prima soluzione, ovvero:
--encrypt-to <l'ID della propria chiave pubblica>

Un esempio dal mio .muttrc:
# Settando questa variabile si specifica a Mutt il comando e relative opzioni
# da utilizzare per cifrare il corpo di un messaggio, senza firmarlo, creando
# un allegato in formato PGP/MIME.
# Valore di default: ""
set pgp_encrypt_only_command="/usr/lib/mutt/pgpewrap gpg -v \
--batch --output - --encrypt --encrypt-to 0xTUAKEYID --textmode \
--armor --always-trust -- -r %r -- %f"

# Settando questa variabile si specifica a Mutt il comando e relative opzioni
# da utilizzare per firmare e cifrare contemporaneamente il corpo di un messaggio,
# creando un allegato in formato PGP/MIME.
# Valore di default: ""
set pgp_encrypt_sign_command="/usr/lib/mutt/pgpewrap gpg \
--passphrase-fd 0 -v --batch --output - --encrypt \
--encrypt-to 0xTUAKEYID --sign %?a?-u %a? --armor \
--always-trust -- -r %r -- %f"

Attenzione che tutte e due le soluzioni proposte hanno il "difetto" di diminuire la sicurezza del messaggio.
Mi spiego: se una sola delle due chiavi utilizzate per la cifratura venisse compromessa, il messaggio potrebbe essere comunque letto. Aumentando le chiavi utilizzate, si aumenta la probabilità di compromissione e, pertanto, si diminuisce la sicurezza.


Una terza e ultima soluzione, spesso suggerita ma ancora più insicura, è quella di settare a yes la variabile fcc_clear in .muttrc, per chiedere a Mutt di salvare nella mailbox specificata con la variabile record i messaggi spediti in modo non criptato e senza l'eventuale firma, anche quando sono criptati e/o firmati.


Come eseguire la verifica della firma in modo non automatico

Potremmo giudicare eccessivo verificare automaticamente la firma di tutti i messaggi firmati, con conseguente ampliamento del numero delle chiavi pubbliche ospitate nel nostro portachiavi.

Ad esempio, in seno alle mailing list, è frequente il caso di persone che inviano messaggi alla lista firmati digitalmente da GnuPG. Di norma non conosciamo queste persone ed i loro messaggi non hanno contenuti tali da rendere opportuna la verifica automatica della autenticità del mittente e della integrità del testo.

La verifica automatica della firma può quindi avere senso quando trattiamo messaggi firmati scambiati tra amici, mentre negli altri casi potremmo preferire la verifica della firma solo dietro nostra richiesta.

A seconda delle nostre necessità possiamo adottare diverse soluzioni. Vediamo le quattro più comuni.


Prima soluzione

La verifica della firma non è mai automatica, ma impostiamo un comando per eseguirla a richiesta.

Per realizzare questa soluzione dobbiamo:
  1. settare a no la variabile pgp_verify_sig in .muttrc
  2. Impostare una macro per eseguire la verifica della firma di un messaggio che abbiamo selezionato nell'indice dei messaggi, oppure visualizzato nel pager.
Di seguito un esempio:
# Settando a no questa variabile, Mutt non verifica
# automaticamente la firma allegata ad un messaggio.
# Valore di default: yes
set pgp_verify_sig=no

# Macro per eseguire la verifica della signature PGP sul messaggio
# attualmente selezionato nell'indice messaggio o visualizzato nel
# pager. Viene utilizzata nel caso in cui si sia deciso di non far
# effettuare automaticamente per tutti i messaggi la verifica
# della firma.
# Si esegue con control-v (v: onomatopeico di Verifica).
macro index \cV "<enter-command>set pgp_verify_sig=yes<enter>\
<display-message><enter-command>set pgp_verify_sig=no<enter>" "Verifica della firma PGP"

macro pager \cV "<enter-command>set pgp_verify_sig=yes<enter><exit>\
<display-message><enter-command>set pgp_verify_sig=no<enter>" "Verifica della firma PGP"

Il difetto di questa macro è che sovrascrive i messaggi prodotti da GnuPG a seguito della verifica della firma (normalmente visualizzati nella input line). Inoltre, non viene aggiornato lo status flag del messaggio da s a S nell'indice dei messaggi. L'esito della verifica, come illustrato in precedenza, viene tuttavia visualizzato nel pager dopo gli header del messaggio e prima del testo.


Seconda soluzione

La verifica della firma non è mai automatica, ma impostiamo un comando per modificare al volo questo settaggio.

Per realizzare questa soluzione dobbiamo:
  1. settare a no la variabile pgp_verify_sig in .muttrc
  2. Impostare una macro, eseguibile dall'indice dei messaggi, che realizza un interruttore che attiva e disattiva la verifica della firma.
Un esempio per questa soluzione è il seguente
# Settando a no questa variabile, Mutt non verifica
# automaticamente la firma allegata ad un messaggio.
# Valore di default: yes
set pgp_verify_sig=no

# Macro per impostare un interruttore del settaggio della verifica
# automatica della firma da parte di GnuPG. Può essere utilizzato
# quando impostiamo a no la verifica automatica, ma vogliamo
# modificare temporaneamente il settaggio.
# Viene eseguita mediante control-s
macro index S " toggle pgp_verify_sig ?pgp_verify_sig"

Quando sono nell'indice dei messaggi e vedo un messaggio firmato (grazie allo status flag "s") che ritengo opportuno verificare, attivo l'interruttore prima di entrare nel pager per la lettura del messaggio stesso; disattivo quindi l'interruttore una volta tornato nell'indice dei messaggi.)


Terza soluzione

La verifica della firma è automatica, tranne che per i messaggi che corrispondono a certi criteri.

Per questa soluzione ricorriamo al settaggio di hook che disattivano la verifica automatica sui messaggi che, di norma, preferiamo non verificare, come quelli che appartengono a mailing list, oppure che sono contenuti in determinate mailbox, ecc...

Vediamo un esempio di applicazione della soluzione mediante i message-hook:
# La verifica della firma è automatica tranne che per i messaggi
# provenienti da mailing list (pattern ~l)
message-hook . 'set pgp_verify_sig=yes'
message-hook ~l 'set pgp_verify_sig=no'

Di seguito un esempio di utilizzo dei folder-hook:
# La veririfica della firma è automatica tranne che per i messaggi
# contenuti in una determinata mailbox
folder-hook . 'set pgp_verify_sig=yes'
folder-hook unacertamailbox 'set pgp_verify_sig=no'

Se qualcuno pensa di integrare questa soluzione con la macro della prima soluzione, ricordi che il momento in cui Mutt verifica la condizione posta con gli hook degli esempi suscritti, non renderebbe di fatto operativa la macro.


Quarta soluzione

Ogni volta che un messaggio viene aperto per la lettura, decidere se verificarne la firma.

Per attuare tale soluzione, sfruttiamo il fatto che la variabile pgp_verify_sig è del tipo quadoption, settandola ad ask-yes o ask-no.

E' un settaggio che, a mio avviso, può risultare noioso.



^top

Il PGP Menu: Come personalizzarlo, che informazioni offre


Come personalizzare le informazioni visualizzate e la loro disposizione

Analogamente a quanto illustrato per gli altri menu nel capitolo dedicato al look&feel, è possibile personalizzare il PGP Menu, settando la variabile pgp_entry_format, il cui valore di default è:
Default: "%4n %t%f %4l/0x%k %-4a %2c %u"

Le informazioni relative alle chiave che possiamo far visualizzare con pgp_entry_format sono:

%n numero progressivo delle chiavi elencate
%t affidabilità/validità dell'associazione chiave-user id
%f flags
%l lunghezza della chiave
%k key id
%a algoritmo utilizzato per la generazione della chiave
%c capacità (possibilità di utilizzo della chiave)
%u user id
%[<s>] data della chiave, ove <s> è una espressione strftime

Come leggere le informazioni relative alle chiavi elencate nel PGP Menu

Non necessitano di spiegazioni gran parte delle informazioni che possono essere visualizzate nel PGP Menu.

Ci limitiamo pertanto a fornire un approfondimento per quelle non autoesplicative.

Il campo %f (flag) fornisce informazioni sullo stato della chiave. Può assumere i seguenti valori e relativi significati:

R Chiave revocata e non utilizzabile
X Chiave scaduta e non utilizzabile
d Chiave che abbiamo disabilitato
c Chiave critica per presenza di auto certificazioni

Il campo %c (capacità) viene valorizzato con due valori, il primo relativo alle capacità della chiave per le operazioni di criptazione, il secondo relativo alle capacità per le operazioni di firma.

I possibili valori e significati del primo carattere (capacità di criptare) sono:

- Chiave non utilizzabile per criptare
. Chiave utilizzabile per criptare
(ma marcata come chiave di firma in uno degli user id)
e Chiave utilizzabile per criptare

I possibili valori e significati del secondo carattere (capacità di firmare) sono:

- Chiave non utilizzabile per firmare
. Chiave utilizzabile per firmare
(ma marcata come chiave di criptazione in uno degli user id)
s Chiave utilizzabile per firmare

Il campo %t (trust) indica quanto è affidabile la chiave per un certo user id. Esso può assumere i seguenti valori e relativi sigificati:

? Chiave con affidabilità non definita
- Chiave con associazioni non affidabili
spazio Chiave con associazioni parzialmente affidabili
+ Chiave completamente affidabile

Di seguito un esempio tratto dal mio .muttrc:

# indica a Mutt quali informazioni associate alle chiavi mostrare nel PGP Menu

set pgp_entry_format="%4n %t%f %[%y/%m/%d] %4l/0x%k %-4a %2c %u"

L'ordinamento delle chiavi elencate nel PGP Menu può essere variato rispetto al default (indirizzo email), settando la variabile pgp_sort_keys

Di seguito un esempio:
# Settando questa variabile si indica a Mutt il criterio di ordinamento
# delle chiavi elencate nel PGP Menu
# address ordina alfabeticamente per user id
# keyid ordina alfabeticamente per key id
# date odina per data di creazione della chiave
# trust ordina per affidabilità della chiave
# Per elencare in ordine inverso premettere `reverse-'.
# Valore di default (sort order): address
set pgp_sort_keys=trust

^top

Configurare Mutt per gestire il vecchio formato inline


In un mondo in cui la gran parte pensa che gli standard siano le regole utilizzate dal più forte, è scontato che molti client di posta non siano ancora compliant con il RFC 2015 che, ricordiamo, definisce lo standard PGP/MIME.
Si pone pertanto il problema di come scambiare messaggi firmati/cifrati con client email non conformi allo standard PGP/MIME.

Come gestire la ricezione di un messaggio firmato e/o criptato alla vecchia maniera

Quando riceviamo messaggi da questi programmi e vediamo che tutto è ancora gestito alla vecchia maniera, con il testo criptato e/o la firma nel corpo del messaggio, possiamo utilizzare la funzione check-traditional-pgp.

La funzione check-traditional-pgp cambia temporaneamente il tipo MIME delle parti del testo del messaggio contenenti i dati "trattati" da PGP, in modo che Mutt possa gestirli per quello che sono (firma digitale del messaggio e/o testo criptato).

La funzione check-traditional-pgp è eseguibile mentre si è in:
Per coloro che utilizzano versioni di Mutt inferiori alla 1.5.7 la funzione va eseguita manualmente:
Premendo ESC P (ESC Shift-p) esegue la funzione check_traditional_pgp

Con versioni di Mutt più recenti la funzione può anche essere eseguita automaticamente, impostando un message-hook come il seguente:

message-hook '!(~g|~G) ~b"^-----BEGIN\ PGP\ (SIGNED\ )?MESSAGE"' "exec check-traditional-pgp"

Attenzione a valutare se e come interagisce questa verifica automatica della firma inline con gli altri settaggi: magari abbiamo configurato che non vogliamo mai verifiche di firma da certi messaggi (vedi soluzioni esposte in precedenza) e questo hook invece le effettua (se verifica il pattern).

Potremmo modificare il message-hook limitando l'esecuzione automatica della gestione in modalità tradizionale ai soli messaggi criptati (ovvero niente verifiche automatiche delle firme):

message-hook '!(~g|~G) ~b"^-----BEGIN\ PGP\ MESSAGE"' "exec check-traditional-pgp"

Nel message-hook illustrato sopra abbiamo utilizzato dei pattern. L'argomento pattern lo abbiamo già trattato illustrando le operazioni di ricerca, limitazione e taggatura, nel capitolo dedicato alla gestione dei messaggi.

Alcuni pattern sono specifici per il riconoscimento di messaggi firmati o criptati e sono:
~g messaggio con firma GnuPG
~G messaggio criptato con GnuPG
~k message contenente una chiave GnuPG

In molti howto, oramai datati, si suggerisce di impostare delle regole con procmail (o equivalente mail filter utilizzato) per aiutare Mutt ad identificare i messaggi che usano il vecchio metodo inline e modificarne gli header.

Se nell'header del messaggio non è specificato che si tratta di un messaggio trattato con PGP/GNuPG, Mutt non se ne accorgerà, visto che è programmato per analizzare l'header del messaggio al fine di decidere come gestirlo.

Avendo a disposizione la funzione check-traditional-pgp, l'utilizzo di tale stratagemma non è più opportuno, ma è sempre possibile. Per chi utilizza procmail, di seguito le regole da inserire nel proprio .procmailrc:

# Verifica ed eventuale correzione
# formato messaggi GnuPG
# Al messaggio viene aggiunto un header che consente a Mutt
# di sapere che esso è firmato, criptato, firmato/criptato, con
# chiave pubblica allegata.
# Inefficace in caso di messaggi multipart

:0
* !^Content-Type: message/
* !^Content-Type: multipart/
* !^Content-Type: application/pgp
{
:0 fBw
* ^-----BEGIN PGP MESSAGE-----
* ^-----END PGP MESSAGE-----
| formail -i "Content-Type: application/pgp; format=text; x-action=encrypt"

:0 fBw
* ^-----BEGIN PGP SIGNED MESSAGE-----
* ^-----BEGIN PGP SIGNATURE-----
* ^-----END PGP SIGNATURE-----
| formail -i "Content-Type: application/pgp; format=text; x-action=sign"

:0 fBw
* ^-----BEGIN PGP PUBLIC KEY BLOCK-----
* ^-----END PGP PUBLIC KEY BLOCK-----
| formail -i "Content-Type: application/pgp-keys; format=text;"
}

Se si utilizza il ramo 1.5 di Mutt, la soluzione più semplice è di settare a yes la variabile pgp_auto_decode che lascia al nostro fido mailer l'incombenza di appurare se ha a che fare con un messaggio PGP tradizionale e di eseguire la decifratura e la verifica della firma, quest'ultima automaticamente o meno, a seconda di quanto previsto dalle regole di comportamento stabilite.


Come creare un messaggio firmato e/o criptato alla vecchia maniera


Quando sappiamo di spedire messaggi che verranno ricevuti da client incapaci di gestire lo standard PGP/MIME, com'è normale con Mutt, abbiamo diverse strade a disposizione:

Se vogliamo seguire la strada di mezzo (in medio stat virtus), per attivare la modalità inline possiamo utilizzare l'interruttore "inline", disponibile direttamente tra le opzioni visualizzate premendo p nel compose menu. Vediamo come utilizzarlo.

Come inviare un messaggio con firma inline

1. scriviamo normalmente il nostro messaggio

2. arrivati al compose menu, premiamo p

3. scegliamo l'azione di firma premendo s
(e)ncrypt, (s)ign, sign (a)s, (b)oth, (i)nline, or (c)lear

4. premiamo nuovamente p

5. scegliamo la modalità inline premendo i
(e)ncrypt, (s)ign, sign (a)s, (b)oth, (i)nline, or (c)lear

6. premiamo y per inviare

5. inseriamo la password di GnuPG e premiamo INVIO

Notiamo che dopo aver scelto di firmare (passo 3), l'header PGP viene valorizzato così:
PGP: Firma (PGP/MIME)
firma come: 0xC9B94521

Dopo aver selezionato l'opzione inline (passo 5), l'header PGP si modifica così:
PGP: Firma (inline)
firma come: 0xC9B94521

Come inviare un messaggio criptato inline

1. scriviamo normalmente il nostro messaggio

2. arrivati al compose menu, premiamo p

3. scegliamo l'azione di criptazione premendo e
(e)ncrypt, (s)ign, sign (a)s, (b)oth, (i)nline, or (c)lear

4. premiamo nuovamente p

5. scegliamo la modalità inline premendo i
(e)ncrypt, (s)ign, sign (a)s, (b)oth, (i)nline, or (c)lear

5. premiamo y per inviare

6. premiamo INVIO quando richiesto (al termine della criptazione)

Notiamo che dopo aver scelto di firmare, l'header PGP viene valorizzato così:
PGP: Crittografa (PGP/MIME)

Dopo aver selezionato l'opzione inline, l'header PGP si modifica così:
PGP: Crittografa (inline)

Utilizzo della funzione pgp_create_traditional

Se ci interessa la terza soluzione, dobbiamo settare a yes la funzione pgp_create_traditional. Questa possibilità può essere di interesse, oltrechè per chi vuole inviare sempre in modalità inline, anche per chi vuole, invece, che Mutt si predisponga automaticamente all'utilizzo della modalità inline qualora ricorrano determinate circostanze. Ovviamente, per realizzare tale "comportamento sindacato", la funzione pgp_create_traditional deve essere utilizzata in abbinata con degli hook.

Vediamo un esempio con i send-hook:
# Utilizziamo PGP/MIME come default
send-hook . 'set pgp_create_traditional=no'

# Utilizziamo il metodo inline per messaggi verso questi indiririzzi
send-hook [email protected]\.it 'set pgp_create_traditional=yes'
send-hook [email protected]\.it 'set pgp_create_traditional=yes'

In un vecchio post ho letto che è noioso dover aggiungere un hook per ciascuno degli indirizzi di coloro che utilizzano mailer menefreghisti. Ma si sottolineava anche che tutto ciò che ha a che fare con questi mailer è di una noia mortale (si parlava di Guardafuori, ovviamente).


Una alternativa, con dei limiti, al send-hook è l'utilizzo dei message-hook.
# Utilizziamo PGP/MIME come default
message-hook . 'set pgp_create_traditional=no'

# Utilizziamo il metodo inline per rispondere a messaggi creati con Guardafuori
message-hook ~h 'X-Mailer:.*Outlook' 'set pgp_create_traditional=yes'

Scontatamente, il message-hook ha effetto sui reply e non sui nuovi messaggi (non ha un header ricevuto da controllare).

Un modo ulteriore, alternativo agli hook, di utilizzare la funzione pgp_create_traditional, è di creare tramite macro un interruttore, che modifica l'impostazione di Mutt relativamente alla creazione di messaggi in formato PGP tradizionale (o inline).

Un esempio da inserire nel .muttrc:
# macro per attivare il modo tradizionale (inline)
macro compose \cp "<enter-command>set pgp_create_traditional=yes<enter><shell-escape>echo -n 'Modalità Inline';sleep 1<enter>" "attivo Inline PGP"

# macro per attivare il modo normale (PGP/MIME)
macro compose \ep "<enter-command>set pgp_create_traditional=no<enter><shell-escape>echo -n 'Modalità PGP/MIME' ; sleep 1<enter>" "attivo PGP/MIME"

La macro può esserci utile nel caso, ad esempio, di una sequenza di messaggi da spedire tutti in modalità inline: modificando il settaggio della variabile pgp_create_traditional, ci evitiamo di selezionare per ciascun messaggio l'opzione inline dal menu richiamato con p. La seconda macro la utilizzeremo per riportare al default il settaggio della variabile.

E' da notare che, quando la variabile pgp_create_traditional è settata a yes (sia in modo definitivo, sia tramite la macro sopra), premendo p nel compose menu, le opzioni che ci vengono presentate cambiano rispetto a quelle viste in precedenza. Non c'è più l'opzione inline, sostituita dall'opzione PGP/MIME:

PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, PGP/M(i)ME, or (c)lear?

Perchè può essere necessario bypassare Mutt per gestire l'inline

Mutt ramo 1.4 (quello trattato in questa guida), quando invia un messaggio pgp inline, pur creando un messaggio text plain, lo qualifica come formato application/pgp, che potrebbe non essere ancora leggibile da mailer incapaci come Guardafuori.

Dalla versione 1.5.1, richiedendo l'utilizzo del metodo inline, Mutt crea più correttamente il messaggio come text/plain e con content-disposition inline (oltrechè con la specifica x-action=pgp-encrypted, o pgp-signed ).

Tuttavia, nelle versioni 1.5 recenti, in caso di messaggi che contengono nel testo caratteri non appartenenti al set us-ascii (es.: lettere accentate) e che si richiede di gestire in modalità inline, Mutt utilizza il set di caratteri utf-8 (è una specifica hardcoded, non modificabile, che bypassa anche i settaggi della variabile send_charset). Anche in tal caso, non tutti i mailer potrebbero ancora essere capaci di utilizzare questo set di caratteri.

Infine, qualora il messaggio sia costituito da più di una singola parte di contenuto MIME (es.: testo + una foto allegata), pur richiedendo il metodo inline, Mutt non può utilizzarlo.

Se facciamo una prova, vediamo infatti che Mutt ci informa di ciò e ci chiede se vogliamo tornare all'utilizzo dello standard PGP/MIME:

Message can't be sent inline. Revert to using PGP/MIME? ([sì]/no):

Rispondendo no, dobbiamo poi provvedere a reimpostare la spedizione senza il trattamento di GnuPG (firma e/o criptazione). Per inviare il messaggio "liscio", ripremiamo p e quindi c, ovvero clear.


Per ovviare a questi problemi, come rimediamo?

Facendo in modo che sia direttamente GnuPG a gestire l'attività (di firma e/o criptazione). Per questo impostiamo delle macro che eseguiremo manualmente per far firmare o cifrare il messaggio in modalità inline:
# Macro utilizzabili prima di inviare la mail dal menu compose.
# Sostituire TUAKEYID con la propria keyid
macro compose \es "<filter-entry>gpg --clearsign -u 0xTUAKEYID\ny" "firma GnuPG inline"
macro compose \ee "<filter-entry>gpg --encrypt --armor\ny" "cifratura GnuPG inline"

Se stiamo spedendo un messaggio multipart (es.: testo + foto allegata), prima di eseguire la macro selezioneremo l'allegato che contiene il testo del messaggio.



^top

Configurare Mutt per GnuPG


Di seguito, la porzione del mio .muttrc dedicata alla configurazione per GnuPG:
## C O N F I G U R A Z I O N E G n u P G
#----------------------------------------------------------------------

# I comandi PGP/GnuPG possono essere eseguiti con opzioni
# che hanno un proprio set di sequenze di tipo printf:

# %p
# Si espande a PGPPASSFD=0 quando è necessaria una password o
# ad una stringa vuota negli altri casi.
# Nota: Può essere utilizzata in un costrutto con a %?.

# %f
# Si espande al nome del file che contiene il messaggio.

# %s
# Si espande al nome del file che, all'interno di un allegato
# multipart/signed contiene la parte relativa alla firma da verificare.

#%a
# Si espande al valore della variabile $pgp_sign_as.

# %r
# Si espande al valore di una o più key ID.
# "-r" permette di specificare il destinatario (ossia la chiave pubblica
# con cui cifrare i dati) sulla linea di comando, invece di farlo
# successivamente in modo interattivo
#----------------------------------------------------------------------


# decommentare la riga seguente se si usa Mutt con versione < 1.3.x
#set pgp_sign_micalg=pgp-sha1 # default for DSS keys

## IMPOSTAZIONI PERSONALI

# Settando a yes questa variabile, Mutt cercherà di firmare sempre
# i messaggi in spedizione utilizzando il formato PGP/MIME.
# Lasciando non settata si potrà decidere di firmare e/o criptare
# utilizzando, dal compose menu, il comando "p".
# Valore di default = no
set pgp_autosign=no


# Settando a yes questa variabile, Mutt cercherà di cifrare sempre
# i messaggi in spedizione utilizzando il formato PGP/MIME.
# Lasciando non settata si potrà decidere di firmare e/o criptare
# utilizzando, dal compose menu, il comando "p".
# Valore di default = no
set pgp_autoencrypt=no


# Avendo più di un paio di chiavi il settaggio di questa variabile
# consente di specificare quale chiave PRIVATA utilizzare.
# Il formato per specificare l'ID della chiave è 0x00112233.
# Valore di default: ""
set pgp_sign_as=0x00112233


# Settando a yes questa variabile, Mutt firmerà automaticamente
# il messaggio di risposta ad un messaggio arrivato firmato
# Il settaggio non opera sui messaggi cifrati E firmati
# Valore di default: no
set pgp_replysign=yes


# Settando a yes questa variabile, Mutt cifra automaticamente un
# messaggio di risposta ad un messaggio arrivato cifrato.
# Valore di default: yes
set pgp_replyencrypt=yes


# Settando a yes questa variabile, Mutt automaticamente firma il
# messaggio di risposta ad un messaggio giunto cifrato.
# La variabile opera in combinazione con $pgp_replyencrypt,
# consentendo di far anche firmare i messaggi che automaticamente
# facciamo cifrare.
# Come visto con la variabile $pgp_replysign Mutt non riesce infatti a
# stabilire se un messaggio cifrato è anche firmato.
# Valore di default: no
set pgp_replysignencrypted=yes


# Settando questa variabile si indica il numero di secondi
# superati i quali la password viene cancellata dalla cache
# se non nuovamente utilizzata.
# Ovvi i rischi di sicurezza se connessi in rete!
# Possiamo sempre usare Ctrl-F per cancellare dalla cache
# la password!
# Valore di default: 300
set pgp_timeout=0


# Settando a yes questa variabile, Mutt cerca automaticamente di
# verificare la firma PGP/MIME allegata ad un messaggio.
# Valore di default (quadoption): yes
# Utilizzando i message-hook si imposta di default la verifica
# automatica, tranne che per i messaggi provenienti da mailing list
set pgp_verify_sig=no


## COMANDI PER VERIFICARE E/O DECRIPTARE MESSAGGI RICEVUTI

# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per decodificare allegati nel deprecato formato
# application/pgp.
# Valore di default: ""
set pgp_decode_command="gpg %?p?--passphrase-fd 0? --no-verbose --batch --output - %f"


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per verificare firme in formato PGP/MIME.
# Valore di default: ""
set pgp_verify_command="gpg --no-verbose --batch --status-fd 2 --output - --verify %s %f"


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per decifrare un messaggio criptato in formato
# PGP/MIME.
# Valore di default: ""
set pgp_decrypt_command="gpg --passphrase-fd 0 --no-verbose --batch --output - %f"


## COMANDI PER FIRMARE E/O CRIPTARE MESSAGGI DA SPEDIRE

# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per firmare un messaggio allegando la firma in
# formato PGP/MIME.
# Valore di default: ""
set pgp_sign_command="gpg --no-verbose --batch --output - --passphrase-fd 0 --armor \
--detach-sign --textmode %?a?-u %a? %f"



# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per firmare un messaggio allegando la firma in
# formato "clearsigned".
# L'utilizzo di questo formato è deprecato (PGP vecchio stile).
# Valore di default: ""
set pgp_clearsign_command="gpg --no-verbose --batch --output - --passphrase-fd 0 \
--armor --textmode --clearsign %?a?-u %a? %f"



# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per cifrare il corpo di un messaggio,
# senza firmarlo, creando un allegato in formato PGP/MIME.
# Valore di default: ""
set pgp_encrypt_only_command="/usr/lib/mutt/pgpewrap gpg -v --batch --output - \
--encrypt --textmode --armor --always-trust -- -r %r -- %f"



# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per firmare e cifrare contemporaneamente il
# corpo di un messaggio, creando un allegato in formato PGP/MIME.
# Valore di default: ""
set pgp_encrypt_sign_command="/usr/lib/mutt/pgpewrap gpg --passphrase-fd 0 -v \
--batch --output - --encrypt --sign %?a?-u %a? --armor --always-trust -- -r %r -- %f"



## COMANDI PER TRATTARE LE CHIAVI

# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per importare nel proprio portafoglio di chiavi
# pubbliche la chiave contenuta in un messaggio firmato ricevuto.
# Valore di default: ""
set pgp_import_command="gpg --no-verbose --import -v %f"


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per esportare una chiave pubblica dal proprio
# portafoglio di chiavi.
# Valore di default: ""
set pgp_export_command="gpg --no-verbose --export --armor %r


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per verificare le informazioni su una chiave
# attraverso il menu di selezione chiavi.
# Valore di default: ""
set pgp_verify_key_command="gpg --no-verbose --batch --fingerprint --check-sigs %r"


# Il testo assegnato a questa variabile verrà analizzato da GnuPg e la
# firma considerata valida se l'output prodotto da $pgp_verify_command
# contiene tale testo. Va adattato al locale utilizzato!.
# Valore di default: ""
#set pgp_good_sign="^gpg: Good signature from \".*<.*@.*>\"$"
#set pgp_good_sign="^gpgv?: Good signature from "
#set pgp_good_sign="^gpg: Firma valida da \".*<.*@.*>\"$"
# Verifica fatta utilizzando il catalogo messaggi di gnupg:
#set pgp_good_sign="`gettext -d gnupg -s 'Good signature from "' | tr -d '"'`"
# Verifica fatta utilizzando lo --status-fd del messaggio
# (bypassa il problema di settare il testo in base al proprio locale)
set pgp_good_sign="^\\[GNUPG:\\] GOODSIG"


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per leggere e visualizzare l'elenco delle
# chiavi pubbliche contenute nel proprio portafoglio.
# Valore di default: ""
set pgp_list_pubring_command="gpg --no-verbose --batch --with-colons --list-keys %r"


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per visualizzare l'elenco delle chiavi private
# contenute nel proprio portafoglio.
# Valore di default: ""
set pgp_list_secring_command="gpg --no-verbose --batch --with-colons --list-secret-keys %r"


# Settando questa variabile si specifica a Mutt il comando e relative
# opzioni da utilizzare per ricercare una chiave pubblica non contenuta
# nel portachiavi %r è l'unico parametro printf-like utilizzabile e
# viene valorizzato con l'indirizzo email corrispondente alla chiave.
# Si raccomanda di NON settare la variabile lasciando a GnuPG il
# compito. Se invece si setta si deve reindirizzare su dev null
# l'output degli errori poichè altrimenti vengono generate delle
# anomalie di visualizzazione (garbage!) che vanno poi risolte con un
# successivo CTRL-l
# Valore di default: ""
# set pgp_getkeys_command="gpg --recv-keys %r > /dev/null 2>&1"


^top

Conclusione

In questo ottavo capitolo abbiamo imparato:

  1. Motivazioni alla firma e criptazione dei messaggi.
  2. Caratteristiche di una sistema di firma digitale a doppia chiave asimmetrica.
  3. Funzionamento di GnuPG.
  4. Invio con Mutt di messaggi firmati e criptati mediante GnuPG.
  5. Gestione con Mutt di messaggi ricevuti che sono stati firmati e criptati con GnuPG.
  6. La configurazione delle variabili dedicate all'interazione tra Mutt e GnuPG.

Ovviamente, se si vuole firmare o criptare un messaggio, è indispensabile non solo aver installato GnuPG, ma anche aver generato la propria coppia di chiavi.

Arrivato a questo punto, non mi rimane che rimandarvi alla tanta documentazione disponibile. La migliore, in quanto ufficiale, è la seguente:


<< Capitolo Precedente Prossimo Capitolo >>