Questo testo è il riadattamento di una guida scritta per essere consultata on-line e pensata per aiutare i principianti a installare il PGP e familiarizzare con esso. Essendo una guida per chi è ancora all'oscuro di tutto, offre una conoscenza tutt'altro che completa. Non ci si stancherà mai di ricordare che, per un uso sicuro e consapevole di PGP, è indispensabile una conoscenza approfondita della documentazione acclusa al software. In rete sono consultabili altri strumenti: basti ricordare il manuale di Zimmermann incluso nel pacchetto di distribuzione del PGP, di cui esiste anche una versione italiana curata da Marco Giaiotto, oppure la guida introduttiva in italiano di Giorgio Chinnici.
La storia del PGP e dei tentativi fatti dai vari governi per impedirne o limitarne la diffusione è lunga e complessa. Nell'introduzione di questo libro sono state delineate le vicende storiche che hanno caratterizzato la nascita di questo software; nel presente capitolo ci si limiterà a sottolineare che a causa di vari motivi - il divieto di esportazione di software di crittografia forte dagli USA, le restrizioni commerciali poste all'impiego dell'algoritmo di crittazione RSA utilizzato da tutte le versioni meno recenti di PGP per la generazione delle chiavi, ecc. - sono proliferate numerose versioni di PGP, la cui effettiva sicurezza è a volte oggetto di dubbio. Senza entrare in dettaglio, basterà dire che per tutti coloro che non risiedono negli USA è universalmente considerata sicura - in base a criteri altrove esposti - oltre che legale, la versione 2.6.3i ("i" sta per internazionale) di Stale Schumacher. Si può rintracciare questa versione - oltre che su http://www.ecn.org/crypto - anche nell'home page internazionale del PGP: http://www.pgpi.com. Questo è il sito più importante per il PGP: contiene tutte le versioni di PGP disponibili per i vari sistemi operativi, più collegamenti, documentazione e una serie di informazioni di vario tipo estremamente utili.
Le versioni più recenti del PGP (a partire dalla 5.0) si differenziano dalle precedenti per due aspetti fondamentali. In primo luogo il programma non funziona più su riga di comando, ma si integra alle interfacce grafiche di diffusi sistemi operativi quali Windows 95/98, NT e Macintosh. In secondo luogo vengono utilizzati algoritmi di crittazione alternativi - come il DiffieHellman - in sostituzione del noto RSA utilizzabile solo nella versione a pagamento per la generazione e la gestione delle chiavi.
Sul PGP 5.0 ci sono state - e sono tuttora in corso - molte discussioni.
Non sembra legittimo considerare "inferiore" la sicurezza offerta da questo sistema, se si tiene presente che anche per esso i sorgenti sono stati resi pubblici, sia pur in maniera inconsueta, attraverso la scansione del libro dove erano pubblicati. Non essendo il libro soggetto a restrizioni di esportazione dagli USA, a partire dalla copia di tali sorgenti Schumacher e collaboratori hanno costruito una versione "internazionale" analoga a quella americana, chiamata PGP 5.0i. Le voci che sono circolate su presunte backdoor di quest'ultima release sono in effetti dovute alla presenza di un'ulteriore versione la 5.5, destinata al mercato delle aziende - che permette (se configurata opportunamente) all'amministratore di sistema la lettura di tutte le lettere crittate dagli impiegati.
Persistono tuttavia alcune perplessità sull'uso del PGP 5.0. A parte il taglio decisamente più commerciale, in questa versione ci sono problemi di compatibilità con le precedenti release: ad esempio, le chiavi create con la nuova versione freeware sono illeggibili per tutte le vecchie versioni (e quindi permettono di comunicare soltanto fra persone che utilizzano il PGP 5.0). In secondo luogo la scelta dell'algoritmo Diffie-Hellman (a detta di molti esperti) sarebbe dovuta non alla ricerca di maggiore sicurezza, ma alla ricerca di un algoritmo non brevettato e di pubblico dominio, libero quindi dal pagamento delle royalty.
La perplessità più grande, riguarda però il fatto che l'integrazione all'interfaccia grafica del sistema operativo, per quanto comodissima, è del tutto trasparente e conduce l'utilizzatore ad un uso puramente meccanico di PGP, senza stimolare una comprensione sostanziale di ciò che sta facendo e del funzionamento del programma. La piena capacità di valutare questi elementi risulta invece fondamentale per padroneggiare in modo realmente sicuro il PGP.
Per questo motivo è meglio avvicinarsi al PGP nella maniera più "dura", magari familiarizzando con la versione 2.6.3i, più spartana e complessa, ma infinitamente più lucida ed evidente. Anche se si utilizza Windows, la 2.6.3i gira benissimo in shell DOS e la scomodità iniziale di dover lavorare dal prompt del DOS è ampiamente compensata dalla migliore comprensione delle modalità di funzionamento del PGP. Quando ci si sentirà in grado di padroneggiare sufficientemente lo strumento, sarà il momento di valutare se conviene o meno passare a versioni successive come la 5.0.
La versione "ufficiale" del PGP 2.6.3i viene distribuita in un file chiamato pgp263i.zip: è la versione base per DOS di Stale Schumacher. Esistono anche altri pacchetti "ufficiali" di questa release con nomi leggermente diversi, come una versione per DOS a 32 bit, versioni per altri sistemi operativi o i file sorgenti.
Dato che esiste sempre il rischio (quello cypherpunk è un mondo giustamente paranoico) che qualcuno stia diffondendo una versione manipolata e insicura del PGP, dovrebbe essere sempre possibile controllare l'integrità del pacchetto pgp263i.zip usando il certificato di firma pgp263ii.asc compreso nel pacchetto di distribuzione, appositamente rilasciato da Schumacher.
È tempo dunque di gettare uno sguardo alla parte tecnica. Una volta procurato il file pgp263i.zip, occorre procurarsi il pr ogramma di decompressione (pkzip/pkunzip) e creare sul proprio disco una directory apposita in cui decomprimere il PGP. Chiameremo per esemplificare questa directory c:\pgp. Eseguita la decompressione, in c:\pgp si dovranno trovare i seguenti file:
============= pgp263ii.asc pgp263ii.zip readme.1st readme.usa setup.doc =============
Concentriamoci ora sulla presenza di un ulteriore pacchetto "zippato" da decomprimere (pgp263ii.zip) che contiene i seguenti file:
=========================================================== config.txt - de.hlp - en.hlp - es.hlp - fr.hlp - keys.asc - language.txt - md5sum.exe - pgp.exe - pgp.hlp - pgpsort.exe ===========================================================
pgp263ii.zip va decompresso usando il comando <pkunzip -d> (o qualsiasi altra opzione del vostro decompressore che ricrei le subdirectory) in modo da creare automaticamente la subdirectory c:\pgp\doc, dove verrà archiviata tutta la documentazione. Bisogna modificare con un qualunque editor ASCII (ad esempio edit.com del DOS o Notepad di Windows) il proprio c:\autoexec.bat, inserendo dopo il path le seguenti esatte stringhe:
======================= SET PGPPATH=C:\PGP SET PATH=C:\PGP;%PATH% SET TZ=MET-1DST =======================
La prima stringa setta la variabile d'ambiente pgppath, la seconda integra il path del PGP al path preesistente; queste due stringhe sono necessarie (ovviamente, se il PGP è stato installato in un'altra directory bisogna indicare il percorso giusto). La terza stringa serve a settare la timezone, in modo che ogni operazione fatta con il PGP rechi l'ora e la data corretta. Salvate le modifiche all'autoexec.bat, occorre aprire con il solito editor di testo il file config.txt che si trova in c:\pgp. Ci si troverà dentro un sacco di roba, che servirà più avanti a configurare il PGP in modo più "evoluto". Per ora non va modificato quasi nulla. Bisogna cercare la seguente stringa:
===================== # Legal_Kludge = off =====================
ed eliminare il cancelletto, ottenendo questo risultato:
=================== Legal_Kludge = off ===================
Questa operazione serve a rendere le chiavi generate con questa versione del PGP compatibili anche con le versioni precedenti. Tutte le informazioni sul legal kludge e sul motivo per cui in USA la compatibilità è diventata un problema legale, hanno il sapore di una telenovela (infinita) e sono gustosamente reperibili (per chi lo desideri) nella documentazione compresa nel pacchetto.
Salvata la modifica al config.txt di PGP, è necessario riavviare il proprio PC per rendere operative le modifiche apportate all'autoexec.bat. Sarà poi utile creare una directory tipo c:\pgp\prova, da utilizzare come campo di battaglia per i successivi tentativi di familiarizzazione con il programma. Il primo comando da battere stando dentro c:\pgp\prova, è:
======== pgp -h ========
Se tutti i passi finora indicati sono stati seguiti correttamente, compariranno le schermate d'aiuto del PGP. Poiché questo è il comando che si usa più frequentemente agli inizi, potrebbe non essere una cattiva idea stampare le schermate in modo da averle sott'occhio facilmente in ogni momento. A questo punto l'installazione è finita. Si può uscire dalla schermata d'aiuto e passare alla generazione della propria coppia di chiavi.
Le chiavi sono il cardine intorno al quale si impernia tutto il sistema della crittazione PGP. Una volta terminata la generazione si avrà la propria chiave pubblica con cui qualunque persona potrà crittare qualunque file desideri (file binari, di testo, eseguibili, eccetera). Soltanto chi avrà accesso alla chiave privata corrispondente (e non si insisterà mai abbastanza sul fatto che solo tu dovresti poter accedere alla tua chiave privata) potrà poi eseguire la decrittazione. Questo discorso può apparire ora illogico o complicato, ma proseguendo nella lettura si scoprirà che non ci vuole molto a capire come si fa. La chiave pubblica e la chiave privata corrispondente vengono generate insieme, con un'unica operazione. Digitando:
======== pgp -kg ========
comparirà la seguente schermata, con cui PGP chiede di scegliere la dimensione (cioè il numero di bit) della coppia di chiavi che si vuol generare:
********************************************************************** Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c)1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/28 20:31 GMT Pick your RSA key size: 1) 512 bits- Low commercial grade, fast but less secure 2) 768 bits- High commercial grade, medium speed, good security 3) 1024 bits- "Military" grade, slow, highest security Choose 1, 2, or 3, or enter desired number of bits: **********************************************************************
Fra le tre opzioni proposte (512, 768 e 1024 bit) è consigliabile la chiave più grande: da 1024 bit. Chiavi più piccoline danno minore sicurezza, mentre una chiavona esagerata (sino a 2048 bit) per ora non offre particolari vantaggi in termini di sicurezza e in più non è compatibile con il PGP versione 2.3a. Per cui si sceglie l'opzione 3 e si vedrà comparire la seguente schermata:
******************************************************************** Generating an RSA key with a 1024-bit modulus. You need a user ID for your public key. The desired form for this user ID is your name, followed by your E-mail address enclosed in <angle brackets>, if you have an E-mail address. For example: John Q. Smith <12345.6789@compuserve.com> Enter a user ID for your public key: ********************************************************************
Il PGP sta chiedendo un nome da associare alla coppia di chiavi (User ID), che può essere costituito da una o più parole e caratteri alfanumerici. Il PGP userà questo User ID per identificare le tue chiavi durante la crittazione\decrittazione dei messaggi. nota 1
È possibile fare in modo che compaia, a fianco del proprio User ID, qualche altra informazione, come ad esempio un indirizzo di e-mail. In questo caso occorre digitare le informazioni aggiuntive tra i simboli < >, ma sebbene sia una pratica molto diffusa se ne può anche fare a meno o si può attuare in seguito. Per esempio, se il tuo alias è "Lametta" puoi limitarti a battere
======== Lametta ========
Oppure, se vuoi comprendere nello User ID anche gli indirizzi di posta elettronica che hai eventualmente a disposizione:
================================ Lametta <joe@luthorcorp.com> ================================
Dopo aver scelto lo User ID, il PGP ti avvertirà di scegliere la tua passphrase.
****************************************************************** You need a pass phrase to protect your RSA secret key. Your pass phrase can be any sentence or phrase and may have many words, spaces, punctuation, or any other printable characters. Enter pass phrase: ******************************************************************
Il PGP chiede di digitare una frase o parola (la passphrase, appunto), senza la quale sarà impossibile accedere alla tua chiave privata. Qualora qualcuno entrasse in possesso della tua chiave privata (che è comunque bene che non vada mai in giro) non potrà ugualmente decrittare i messaggi crittati con la tua chiave pubblica, a meno che non conosca anche la passphrase. Per la passphrase puoi utilizzare tutte le lettere, numeri, spazi e segni di punteggiatura che puoi battere. Cerca un compromesso tra una frase abbastanza facile da ricordare (non dovrebbe mai essere scritta da nessuna parte) e abbastanza strana da non poter essere facilmente immaginata (scegliere come passphrase "tanto va la gatta al lardo..." o il nome di battesimo del tuo amore, o la data di nascita di tuo figlio è l'equivalente di scegliere "pippo" come User ID...). Probabilmente la miglior soluzione è rappresentata da una frase facilmente memorizzabile da parte tua, anche se non facilmente collegabile a te da chi ti conosce, inframmezzata da caratteri numerici e simboli. nota 2 Batti la passphrase che hai scelto e vedrai comparire:
***************************** Enter same pass phrase again: *****************************
Qui bisogna ribattere la passphrase scelta per conferma (se si sbaglia a batterla verrà chiesto di reinserirla e riconfermare da capo). Comparirà infine:
*********************************************************************** Note that key generation is a lengthy process. We need to generate 824 random bits. This is done by measuring the time intervals between your keystrokes. Please enter some random text on your keyboard until you hear the beep: 824 ***********************************************************************
Il PGP sta chiedendo di battere a caso sulla tastiera un certo numero di volte per introdurre un ulteriore elemento di casualità nella generazione delle chiavi. Se obbedisci a quest'ultima richiesta, il PGP ti ringrazierà cortesemente:
*************************** * -Enough, thank you. ***************************
E poi, mentre rumina per costruire le chiavi farà scorrere 'sta roba:
================================================================= ............****...........****...........****..........****..... =================================================================
Ci può volere un po' di tempo, a seconda della potenza della macchina. Alla fine si vedrà comparire:
**************************************** Pass phrase is good. Just a moment.... Key signature certificate added. Key generation completed. ****************************************
E le chiavi sono pronte.
Mentre ruminava, il PGP ha creato le chiavi e due file particolari, i cosiddetti "mazzi di chiavi" (keyring) nei quali conserva le chiavi stesse. Se si sono seguite le indicazioni finora offerte, i due keyring si troveranno in c:\pgp. Si chiameranno pubring.pgp (che contiene le chiavi pubbliche) e secring.pgp (che contiene le chiavi private).
Per ottenere la propria chiave pubblica da mandare in giro per il mondo, bisognerà estrarla dal pubring.pgp (vedremo più tardi come), esattamente come per consegnare ad un amico la chiave di casa bisogna sfilarla dal mazzo di chiavi. La chiave privata invece va conservata dentro il secring.pgp e serve a decifrare i messaggi che le persone che desiderano comunicare privatamente con noi critteranno con la nostra chiave pubblica. nota 3 Per ora nei keyring ci sono solo le due chiavi appena generate. Per visualizzarle bisogna digitare il comando:
======== pgp -kv ========
comparirà una scritta tipo:
********************************************************************* Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/28 20:41 GMT Key ring: 'c:\pgp\pubring.pgp' Type Bits/ KeyID Date User ID pub 1024/ C4E35621 1998/10/28 Lametta <joe@luthorcorp.com> 1 matching key found. **********************************************************************
Nelle ultime quattro righe, il PGP scrive da quale keyring sta visualizzando la chiave (in questo caso da c:\pgp\pubring.pgp) e poi dà una serie di informazioni, cioè:
- tipo di chiave (pub, per pubblica)Il comando <pgp -kv>, battuto senza indicare il path del keyring, visualizza di default le chiavi pubbliche contenute nel pubring.pgp, in qualunque directory si stia lavorando. Per visualizzare le chiavi private contenute nel secring.pgp, si usa lo stesso comando, aggiungendo però il percorso completo (full path) nel quale si trova il secring, in questa maniera:
=========================== pgp -kv c:\pgp\secring.pgp ===========================
Si ottiene così questa schermata:
*********************************************************************** Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/28 21:58 GMT Key ring: 'c:\pgp\secring.pgp' Type Bits/ KeyID Date User ID sec 1024/ C4E35621 1998/10/28 Lametta <joe@luthorcorp.com> 1 matching key found. ************************************************************************
Stavolta il PGP informa che il keyring visualizzato è il secring.pgp e la chiave è segreta (sec). A parte questo, gli altri dati (compreso KeyID e User ID) sono uguali. Verificato che le chiavi sono a posto nei loro keyring, passiamo finalmente a crittare un file.
Il PGP può produrre file crittati direttamente in binario, oppure li può rivestire di una "armatura di trasporto" (armor) che rappresenta i dati binari in caratteri ASCII stampabili. Questa seconda opzione è estremamente importante, perché il formato ASCII va utilizzato per tutto ciò che si vuol trasmettere via posta elettronica (messaggi, chiavi pubbliche, file) in quanto i dati binari potrebbero subire alterazioni durante il transito sui vari sistemi, divenendo illeggibili o indecodificabili.
Per semplificare proviamo però prima a crittare un file in formato binario. Questo formato è utile per tutto ciò che si vuole nascondere a occhi estranei, siano file di testo o file eseguibili, purché non li si voglia spedire nel corpo di un messaggio o di una e-mail. È essenzialmente la migliore soluzione per ciò che si vuole conservare crittato su disco o dischetto nota 4 o che si desidera spedire in file attach, perché "pesa" di meno del suo corrispondente ASCII. Creiamo dunque un piccolo file di prova, con un editor di testo (bastano un paio di righe) e salviamolo con il nome prova.txt, nella directory c:\pgp\prova. Per crittare si usa il comando:
================ pgp -e prova.txt ================
e si ottiene:
********************************************************************** Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/30 19:08 GMT Recipients' public key(s) will be used to encrypt. A user ID is required to select the recipient's public key. Enter the recipient's user ID: **********************************************************************
Il PGP sta chiedendo uno o più User ID corrispondenti alle chiavi pubbliche per le quali si desidera crittare il file. Digitiamo la nostra User ID (nell'esempio che stiamo portando avanti: Lametta). In questo modo solo tu (o meglio solo chi ha l'accesso alla tua chiave privata) potrai decrittare il messaggio. Comparirà quindi la scritta:
*********************************************************** Key for user ID: Lametta <joe@luthorcorp.com> 1024-bit key, key ID C4E35621, created 1998/10/28 Ciphertext file: prova.pgp ***********************************************************
Prova.pgp è il file binario (ciphertext) in cui è stato crittato il file originale prova.txt. Il PGP assegna automaticamente al file crittato lo stesso nome del file da crittare, modificandone però l'estensione, che nel caso dei file binari è appunto <.pgp>
Nell'esempio appena riportato, non c'è stato bisogno di indicare il path di prova.txt sulla linea di comando del PGP, perché si stava lavorando nella stessa directory c:\pgp\prova dove già si trova il file. Se prova.txt si fosse trovato in una directory diversa, il PGP non sarebbe riuscito a trovarlo e avrebbe dato un messaggio d'errore. Quindi, per crittare un file che non si trova nella stessa directory dove stai lavorando devi indicare il full path del file sulla linea di comando del PGP. Se ora cambi directory e digiti:
============================= pgp -e c:\pgp\prova\prova.txt =============================
vedrai la solita richiesta di battere lo User ID. Una volta fatto, comparirà:
********************************************************************* Key for user ID: Lametta <joe@luthorcorp.com> 1024-bit key, key ID C4E35621, created 1998/10/28 Output file 'c:\pgp\prova\prova.pgp' already exists. Overwrite (y/N)? *********************************************************************
Siccome esiste già un file prova.pgp nella directory c:\pgp\prova, il PGP lo "vede" e chiede se si desidera sovrascriverlo. Battendo y (yes) si otterrà:
**************************************** Ciphertext file: c:\pgp\prova\prova.pgp ****************************************
Il PGP crea automaticamente il file crittato nella stessa directory in cui si trova il file da crittare. Poiché in questo momento non siamo in tale directory, il PGP si premura di indicare sullo schermo il percorso completo del file prova.pgp. nota 5 Il file appena creato è un file binario e non va inserito nel corpo di un messaggio da postare in rete. Infatti aprendolo con un editor di testo si vedrà una roba del genere:
=============== + "_-+=i-V!__ ===============
Come abbiamo detto, se questi caratteri venissero inseriti nel corpo di un messaggio, passando attraverso sistemi operativi diversi potrebbero venire alterati, rendendo illeggibile o indecifrabile il messaggio stesso. Per i file che si desidera inserire nel corpo di un messaggio per la posta elettronica si utilizza sempre il parametro "-a", il cui compito è creare un armor in caratteri ASCII che "protegga" il nostro messaggio da possibili alterazioni. Vediamo un esempio pratico di crittazione di un file in ASCII da spedire nel corpo di un messaggio. Il comando da digitare è:
================= pgp -ea prova.txt =================
Si presenterà la solita schermata con la richiesta di uno o più User ID (ovviamente valgono le stesse osservazioni precedentemente fatte per il path).
Alla fine del processo di crittazione il PGP indicherà una schermata un po' diversa:
******************************** Transport armor file: prova.asc ********************************
Il file creato si chiamerà dunque prova.asc (e non più prova.pgp). L'estensione <.asc> è quella che il PGP assegna ai file crittati in formato ASCII (transport armor file). nota 6 Anche i file binari non crittati, come ad esempio quelli compressi con pkzip, per essere inseriti nel corpo di un messaggio devono essere "tradotti" in caratteri ASCII, usando appositi programmi (tipo il noto uuencode). È possibile usare anche il PGP per questo scopo di "traduzione in ASCII" senza necessariamente crittare il file. Maggiori informazioni su questo utilizzo si trovano nella documentazione acclusa al programma.
Ma torniamo al nostro file prova.asc. Aprendolo con un editor di testo si vedrà un tipico messaggio PGP, che si presenta più o meno così:
================================================================ -----BEGIN PGP MESSAGE----- Version: 2.6.3i hIwDwbyr5cTjViEBA/9sqh3uRHUSV0wjkFIp7t36dWRn0vnuZgw4b+15hRNaegeq ujTHw7SRxR5k7FrR6TJ/S8+BuQ2Fg7yy3P/zaO7AH3Awdmcu6AR3p0gthNw3mNxC dMQY/VGovGcu9RGZsJKNRd2GlHgckIIYWr9VyfALfB5ViRWkBXeR/pvD+b31KKYA AAAn9R17tj2/E9r6JX/N/Z+OjNo4oxzjllp/mmgnaYqfiFZkAD2YAkkh =9H9y -----END PGP MESSAGE----- ================================================================
La seconda linea del testo PGP, informa sulla versione del PGP che è stata utilizzata per crittare il messaggio. Le stringhe:
-----BEGIN PGP MESSAGE-----
e
-----END PGP MESSAGE-----
ovvero gli header del PGP, sono fondamentali, in quanto consentono al PGP di riconoscere come crittato il testo tra esse compreso. Bisogna fare attenzione a non cancellarle né alterarle, ad esempio quando si vuol fare un "copia e incolla" per importare o esportare un messaggio PGP da un editor di testo al programma che usiamo per la posta elettronica e viceversa, altrimenti il PGP non riconoscerà il testo come crittato, si rifiuterà di decrittarlo e darà solo uno sconsolante messaggio d'errore.
Prima o dopo le stringhe
-----BEGIN PGP MESSAGE-----e
-----END PGP MESSAGE-----può stare senza problemi del testo non-PGP, cioè del semplice testo scritto da noi. Anche se si trova dell'altro testo, il PGP decritterà solo la parte crittata, cioè quella compresa tra le stringhe, fin tanto che (inutile dirlo) le stringhe o il testo fra esse contenuto non sia alterato. Ci sono scopi molto particolari (e attuabili solo da utenti un po' esperti) per cui può essere necessario togliere gli header del PGP, cioè cancellare le stringhe di inizio e fine messaggio. Ad esempio in alcune reti telematiche è vietato scambiarsi messaggi crittografati. Per far rispettare un simile divieto i computer che veicolano i messaggi sono dotati di particolari programmi, detti bot (da robot), che intercettano automaticamente le stringhe
-----BEGIN PGP MESSAGE-----e
-----END PGP MESSAGE-----e rimandano indietro al mittente il messaggio che le contiene. Siccome il livello di intelligenza di simili bot è ancora sufficientemente basso, un modo per ingannarli è cancellare le stringhe di begin e end. Il destinatario dovrà poi reinserirle a mano (rispettando la posizione originale) e decrittare normalmente il messaggio. Esistono però (ed esisteranno sempre di più) bot meno idioti che riescono a intercettare i messaggi PGP identificando oltre agli header anche alcune sequenzialità tipiche degli algoritmi di crittazione usati dal PGP. È questo un classico caso in cui possono risultare utili quei programmi di steganografia (trattati più avanti in questo libro) che consentono di nascondere testo, crittato o meno, all'interno di file contenenti immagini, suoni o altro.
Per decrittare un file crittato, sia binario, sia ASCII, basta battere <pgp nomefile> senza altri parametri (valgono sempre le solite considerazioni sul path). Nel nostro caso, per decrittare il file che abbiamo appena creato, bisogna digitare <pgp prova.asc> e si vedrà:
*********************************************************************** Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/30 20:57 GMT File is encrypted. Secret key is required to read it. Key for user ID: Lametta <joe@luthorcorp.com> 1024-bit key, key ID C4E35621, created 1998/10/28 You need a pass phrase to unlock your RSA secret key. Enter pass phrase: ***********************************************************************
Il PGP riconosce il file come crittato, avvisa che per decrittarlo occorre una chiave privata e chiede la corrispondente passphrase. Dopo averla digitata, se non è sbagliata si vedrà:
*********************************************************************** Enter pass phrase: Pass phrase is good. Just a moment...... Plaintext filename: prova ***********************************************************************
Il PGP ha decrittato il file e ha creato un nuovo file a cui ha assegnato automaticamente il nome del file crittato (prova) ma senza nessuna estensione. Valgono ovviamente per le decrittazione le stesse considerazioni già fatte per il path. Aprendo con un editor il file c:\pgp\prova\prova si potrà controllare che la decrittazione sia avvenuta senza intoppi.
Sin qui abbiamo parlato di crittare\decrittare un file in binario oppure in ASCII con il proprio paio di chiavi, il che è già sufficiente per garantirsi la riservatezza dei dati presenti sull'hard disk. Ma il PGP serve anche e soprattutto per scambiare messaggi con altre persone. In questo caso bisogna ovviamente avere a disposizione la loro chiave pubblica e mettere a loro disposizione la propria. Per fare questo bisogna superare un ulteriore passaggio: importare le chiavi pubbliche di altre persone nel proprio pubring.pgp ed esportare la propria chiave pubblica in un file che possa essere diffuso via rete o su dischetto.
Per ottenere la chiave pubblica di qualcuno si può chiedere direttamente alla persona interessata (che la può consegnare a mano su un dischetto o può spedirla via posta elettronica) oppure (come si vedrà più avanti) si possono utilizzare delle speciali macchine, dette keyserver, dedicate alla gestione delle chiavi pubbliche PGP su Internet. Una chiave pubblica ha questo formato:
================================================================ Type Bits/KeyID Date User ID pub 1024/90653321 1998/02/03 Lex Luthor <lex@luthorcorp.com> -----BEGIN PGP PUBLIC KEY BLOCK----- Version: 2.6.3i Comment: PGP 2.x compatible mQCNAjTXBdgAAAEEANStJZjQZQpIE/0teO/Oo7Y52ESv7usdCrH3BSqLr14QGQpl +A+0z4UNlMYr+oNS8/xaNlriBdqWtrj8Ow3vydL12kdHjbtpNT180HlekU3+l263 /fKlLBXyOE1UWIRExvnVmX9qNd2xOszse+SwTzl9PICsJjxEvTt1dOqQZTMhAAUR tB9MZXggTHV0aG9yIDxsZXhAbHV0aG9yY29ycC5jb20+iQCVAgUQNNcF2Tt1dOqQ ZTMhAQGUYAP/c+iZSKAZ4juy+cB/H5PdeUSp14NYn8KkAs84tgq+dscG0EQB4vRa v5ZOkcZTARnV3EU0tEVb+Ube7TSfSjPugD4JEe+/uIRJgJhbfZXbh3uBngLNHshn NgWBT9/RCBELwvjAv17xu3chhL0xTIq7GNpcy6iJies/6GGndUc2pwg= =LWqw -----END PGP PUBLIC KEY BLOCK----- ================================================================
In pratica non è altro che un semplice file di testo in formato ASCII. I keyfile sono i file contenenti le chiavi in formato ASCII destinate ad essere diffuse per posta elettronica. Una chiave pubblica può benissimo essere inserita in un messaggio o in una e-mail. Comunque sia, una volta ottenuta la chiave, va copiata in un keyfile. Supponiamo di aver ricevuto via posta elettronica la chiave pubblica sopra riportata. Per prima cosa la salveremo su un file dal nome luthor.asc (per convenzione si dà al file il nome dello User ID della chiave) in c:\pgp\prova. Per importarla nel proprio keyring si digita (valgono le solite considerazioni sul path):
================== pgp -ka luthor.asc ==================
il risultato sarà:
************************************************************************* Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/02/04 00:17 GMT Looking for new keys... pub1024/90653321 1998/02/03 Lex Luthor <lex@luthorcorp.com> Checking signatures... Keyfile contains: 1 new key(s) One or more of the new keys are not fully certified. Do you want to certify any of these keys yourself (y/N)? *************************************************************************
La chiave risulta nuova per il pubring.pgp e non certificata: nessuno, cioè, garantisce che quella chiave appartenga effettivamente alla persona a cui si suppone debba appartenere. nota 7 Il PGP chiede se si desidera certificare personalmente la chiave che si sta introducendo nel pubring.txt. È buona norma non certificare mai una chiave di cui non si è pienamente sicuri, per cui il 99% delle volte a questa domanda si risponde no.
A questo punto il PGP inserirà la chiave pubblica nel pubring.pgp senza dare un ulteriore messaggio di conferma. Si può usare <pgp -kv> per controllare l'avvenuto inserimento. Usato senza ulteriori specificazioni il comando visualizzerà tutte le chiavi, mentre digitando <pgp -kv User ID> (in questo caso <pgp -kv luthor>) verrà visualizzata solo la chiave che si desidera. nota 8 Per inviare ad altre persone la propria chiave pubblica è necessario crearsi un keyfile che la contenga. Il comando per esportare su file una public key dal pubring è:
========= pgp -kxa =========
che produce la seguente schermata:
************************************************************************* Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/31 00:32 GMT A user ID is required to select the key you want to extract. Enter the key's user ID: *************************************************************************
Il PGP chiede lo User ID della chiave da estrarre, in questo caso il proprio User ID: Lametta.
************************************************************************ Extracting from key ring: 'c:\pgp\pubring.pgp', User ID "Lametta". Key for user ID: Lametta <joe@luthorcorp.com> 1024-bit key, key ID C4E35621, created 1998/10/28 Extract the above key into which file? *************************************************************************
e poi chiede in quale file estrarre la chiave. In genere si usa un nome di file che corrisponde allo User ID (Lametta, nel nostro caso) con estensione <.asc>, cioè lametta.asc. Va naturalmente specificato il path se si desidera che sia creato in una directory diversa da quella in cui si sta lavorando, ad esempio:
=================== c:\pgp\lametta.asc ===================
Il PGP risponderà:
********************************************* Transport armor file: c:\pgp\lametta.asc Key extracted to file 'c:\pgp\lametta.asc'. *********************************************
Ora aprendo con un editor di testo il keyfile c:\pgp\lametta.asc si potrà rimirare la propria chiave pubblica. Naturalmente per estrarre la chiave in un'unica operazione, si poteva anche benissimo digitare sin dall'inizio:
=================================== pgp -kxa lametta c:\pgp\lametta.asc ===================================
e risolvere tutto in un unico passaggio. Va però ricordato che il PGP è sensibile all'ordine dei parametri sulla linea di comando e finché non si è padroni della sintassi è facile sbagliare. Prova a invertire l'ordine dei parametri e a digitare:
=================================== pgp -kxa c:\pgp\lametta.asc lametta ===================================
e vedrai che il PGP interpreta c:\pgp\lametta.asc come lo User ID della chiave pubblica da estrarre: non trovando alcun lametta.asc fra gli User ID l'operazione finisce con il solito, laconico messaggio d'errore.
Siamo ormai a buon punto. Per scrivere un messaggio PGP bisogna innanzitutto preparare un file di testo con il solito editor. Salveremo questo testo in un file dal nome message.txt nella solita directory c:\pgp\prova. Per crittare il messaggio con una o più chiavi pubbliche (in modo che sia decrittabile da una o più persone), si digita il comando:
======================================= pgp -ea message.txt luthor <tuoUserID> =======================================
È buona norma crittare ogni messaggio anche con la propria chiave pubblica, in modo da poterlo decrittare in caso di necessità. Per inviare un messaggio crittato, si poteva anche solo battere <pgp -ea message.txt luthor>, ma in questo caso non sarebbe stato più possibile decrittare quel che si era scritto, il che spesso è scomodo. Se si desidera che altre persone siano in grado di decrittare il messaggio, basta battere <pgp -ea prova.txt luthor lametta pippo> - posto naturalmente che si sia importata precedentemente nel proprio pubring.pgp anche la chiave pubblica di Pippo. La risposta del PGP sarà:
************************************************************************* Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01- 18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/31 01:06 GMT Recipients' public key(s) will be used to encrypt. Key for user ID: Lex Luthor <lex@luthorcorp.com> 1024-bit key, key ID 90653321, created 1998/02/03 WARNING: Because this public key is not certified with a trusted signature, it is not known with high confidence that this public key actually belongs to: "Lex Luthor <lex@luthorcorp.com>". Are you sure you want to use this public key (y/N)? *************************************************************************
Come si ricorderà, quando il PGP aveva chiesto se si voleva certificare la chiave pubblica che si stava importando nel pubring, si era risposto di no. Dato che la chiave non è certificata, il PGP ti chiede se vuoi usarla lo stesso. Rispondi di sì (y = yes) e tieni presente che se invece rispondi di no (e per rispondere no basta battere invio poiché il no è di default) il PGP non userà la chiave non certificata e critterà il messaggio solo con la tua chiave - senza ulteriori avvisi - e quindi il destinatario non potrà decrittare e leggere il messaggio.
Dopo che si è risposto di sì una volta per confermare l'uso di una chiave non certificata, il PGP non chiederà più ulteriori conferme per quella specifica chiave, limitandosi ad avvertirti che non è certificata ogni volta che la si usa. Dopo aver risposto y si vedrà:
************************************************************************ Key for user ID: Lex Luthor <lex@luthorcorp.com> 1024-bit key, key ID 90653321, created 1998/02/03 Key for user ID: Lametta <joe@luthorcorp.com> 1024-bit key, key ID C4E35621, created 1998/10/28 Transport armor file: message.asc ************************************************************************
Il messaggio crittato si trova nel file c:\pgp\prova\message.asc. Si può ora copiarlo e spedirlo con la posta elettronica, ragionevolmente certi che solo il destinatario e noi stessi saremo in grado di decrittarlo e leggerne il contenuto. Per curiosità, ripeti lo stesso comando <pgp -ea message.txt luthor lametta> per vedere come si comporta il PGP usando nuovamente la chiave non certificata.
Una particolarità: dato che il PGP riconosce sulla linea di comando anche una stringa solo parzialmente corrispondente a uno User ID, non è sempre necessario battere lo User ID completo. Ad esempio basta digitare luthor oppure lex per crittare un messaggio per lex luthor. La comodità delle abbreviazioni può però a volte creare problemi in caso si posseggano due o più chiavi pubbliche parzialmente coincidenti. Ad esempio se si conserva nel pubring la chiave pubblica di lex luthor e quella di dura lex, digitando solo il pezzo di User ID lex, il PGP fermerà la ricerca della chiave corrispondente al primo User ID comprendente la stringa lex che trova nel pubring (cioè critterà di default il messaggio con la chiave pubblica che è stata aggiunta più di recente). In questi casi ci vuole un po' di attenzione nella scelta della porzione di User ID da digitare. Va tenuto presente che il PGP riconosce come parte dello User ID anche l'indirizzo e-mail eventualmente inserito assieme allo User ID. Bisogna fare un po' di prove, digitando porzioni di stringa diverse, per impratichirsi nel meccanismo.
Ipotizziamo di aver ricevuto un messaggio PGP. Immediatamente lo salviamo su un file in formato ASCII (quasi tutti i programmi di posta elettronica hanno un'opzione per farlo) dandogli il nome che più ci aggrada: in questo esempio receive.txt. Per decrittare il file basta battere il comando PGP seguito dal nome del file:
================ pgp receive.asc ================
la risposta sarà:
*************************************************************************** Pretty Good Privacy(tm) 2.6.3i - Public-key encryption for the masses. (c) 1990-96 Philip Zimmermann, Phil's Pretty Good Software. 1996-01-18 International version - not for use in the USA. Does not use RSAREF. Current time: 1998/10/31 01:43 GMT File is encrypted. Secret key is required to read it. Key for user ID: Lametta <joe@luthorcorp.com> 1024-bit key, key ID C4E35621, created 1998/10/28 You need a pass phrase to unlock your RSA secret key. Enter pass phrase: ****************************************************************************
bisogna digitare la propria passphrase:
*********************************************************************** Enter pass phrase: Pass phrase is good. Just a moment...... Plaintext filename: receive ***********************************************************************
A questo punto basta aprire con un editor di testo il file receive (senza estensione perché il PGP salva così di default) e leggere il messaggio. Digitando nuovamente <pgp receive.asc> e battendo invio al momento in cui il PGP chiede la passphrase, si vedrà che nel negare l'accesso alla chiave privata, il PGP riporta il nome degli User ID che sono abilitati a decrittare il messaggio. Questo può essere un modo rapido per controllare se il messaggio è effettivamente crittato con tutte le chiavi che si intendeva usare. Ma può essere anche un momento di debolezza: qualunque altra persona può vedere a chi è destinato quel messaggio, anche se naturalmente non sarà in grado di leggerne il contenuto. Per questo motivo in certe circostanze può essere opportuno inserire come User ID della propria chiave un nome di fantasia o addirittura nessun nome (in questo caso la chiave verrà identificata esclusivamente da una stringa di caratteri alfanumerici generata automaticamente e univocamente per ogni chiave). Per lo stesso motivo si può anche evitare di inserire il proprio indirizzo e-mail.
Questo è il momento di usare il PGP operativamente; si può cominciare a distribuire la propria chiave pubblica, magari prima in matrix o via e-mail a qualche amico che usa il PGP, per tentare qualche scambio e verificare se tutto è a posto. Se non ci sono problemi, è tempo di diffondere la propria chiave a vasto raggio. Se si desidera, si può anche inserirla su qualche keyserver (le istruzioni sono più avanti). Naturalmente bisogna anche farsi mandare e\o procurarsi le chiavi pubbliche delle persone con cui si corrisponde. Nel frattempo è utile guardarsi bene la documentazione allegata al PGP, approfondendo la padronanza dello strumento, poiché qui si è parlato solo dei primi rudimenti necessari.
Il passo successivo probabilmente sarà l'uso di una shell, cioè di un programma di interfaccia, per collegare il PGP direttamente al proprio programma di posta (così da evitare i continui copia/incolla). Prima di concludere il capitolo, vanno ancora posti alcuni problemi piuttosto importanti.
La prima cosa da sottolineare è che l'uso di un sistema crittografico come il PGP può generare un falso senso di sicurezza. Bisogna rammentare sempre che PGP di per sé non dice nulla sulla persona con cui si stanno scambiando messaggi (magari critici) e che la regola d'oro rimane sempre la solita: chiunque nel ciberspazio potrebbe essere uno sbirro (e pure fuori). Da sottolineare anche che chiave privata e passphrase del tuo interlocutore potrebbero essere cadute in mano di altri a sua insaputa. Oppure potrebbe anche aver passato dei guai ed essere stato costretto - a tua insaputa - a cedere la sua chiave privata ad altri, che magari stanno continuando a scambiare messaggi con te al posto suo.
Ricorda anche che al momento in cui i guai li passi tu e hai in giro molti messaggi mandati ad altri interlocutori, non puoi essere sicuro che essi non abbiano ceduto sotto pressione la loro chiave, consentendo così la decifrazione dei tuoi messaggi, anche se tu hai tenuto la bocca chiusa... Ma tutto ciò ha poco a che fare con la valutazione di un sistema crittografico e molto a che fare con valutazioni di altra natura.
Diciamo invece che per motivi tuoi hai fiducia nel tuo interlocutore e quindi vuoi essere sicuro che la sua chiave pubblica - sebbene non consegnata a mano, ma pescata da qualche parte o inviata per e-mail - sia davvero la sua. Come fai? Nulla vieterebbe ad un eventuale "terzo incomodo" di inviare una chiave pubblica su un keyserver a nome del tuo amico, oppure di intercettare la tua e-mail e di rispondere al posto suo, inviando una chiave a nome del tuo amico e intercettando poi la tua risposta... Il PGP possiede un comando:
==================== pgp -kvc <user_ID> ====================
che consente di visualizzare il key fingerprint, cioè una serie di caratteri alfanumerici che può essere prodotta da una chiave pubblica e solo da quella, proprio come un'impronta digitale. nota 9 Il fingerprint di una chiave pubblica si presenta così:
================================================================ Key fingerprint = 04 FA 8C FC 27 EB 2F 5128 D2 39 84 73 08 30 AA ================================================================
Il fingerprint serve se trovi da qualche parte una chiave pubblica attribuita a Lex Luthor e hai dei dubbi sulla sua veridicità. Se conosci Lex potresti estrarre il fingerprint dalla chiave sospetta, telefonargli e confrontarlo con il suo, in modo da verificare con lui che la chiave sia quella autentica. È un modo più semplice che non confrontare tutti i caratteri che compongono la chiave pubblica... Non solo. Con il comando:
========================== pgp -kvc > fngrprnt.asc ==========================
si può salvare su file il fingerprint della propria chiave pubblica. Una buona abitudine è quella di inserire il proprio fingerprint nella firma della propria posta elettronica, in modo che compaia su tutti i messaggi che invierai. È così possibile verificare la corrispondenza tra quel fingerprint (diffuso a largo raggio) e quello di tutte le copie della tua chiave pubblica che ci sono in giro.
Il PGP offre molte altre possibilità in tema di "sicurezza" che andrebbero approfondite. In primo luogo il sistema della certificazione delle chiavi, basato sulla fiducia verso una persona che conosci e con cui è avvenuto uno scambio di chiavi in modo sicuro. Questa persona può garantirti, firmandola, una nuova chiave pubblica appartenente a una terza persona che non conosci. Nota però che è preferibile non usare il sistema della certificazione piuttosto che usarlo con leggerezza. Considerazioni approfondite su questo aspetto si possono trovare nella documentazione del PGP.
La firma elettronica è un ulteriore argomento: è possibile firmare usando la propria chiave privata un messaggio o un testo, che sia crittato oppure in chiaro. Anche qui è bene prestare attenzione: benché attestare in questo modo di essere l'autore di un messaggio possa essere molto utile in certe situazioni, una volta che l'hai firmato ti sarà molto più difficile negare di esserne l'autore, qualora se ne presentasse la necessità...
Infine esiste la generazione di un attestato di firma per un file, separato dal file stesso di cui si vuole attestare l'autenticità, metodo che viene solitamente usato per file molto grossi o per firmare file eseguibili e programmi. Anche per queste questioni, è necessario leggere approfonditamente la documentazione.
I keyserver sono particolari server presenti su Internet, dedicati al deposito e al prelievo delle chiavi pubbliche. Sono in rete tra loro, per cui ogni chiave immessa in un server viene diffusa anche sugli altri. Per ricevere o immettere chiavi bisogna inviare un'e-mail all'indirizzo del keyserver. In Italia è solitamente utilizzato:
============================ pgp-public-keys@dsi.unimi.it ============================
I comandi al keyserver vanno scritti nel "subject" dell'e-mail: per ricevere una chiave pubblica basta inviare al keyserver una e-mail, contenente nel subject il comando GET seguito dallo User ID della chiave richiesta. Chi vuole la chiave pubblica di Lex Luthor scriverà un e-mail così:
================================ To: pgp-public-keys@dsi.unimi.it From: joe@luthorcorp.com Subject: GET lex@luthorcorp.com ================================
o anche solo GET luthor, senza aggiungere nulla nel corpo dell'e-mail. Per depositare la propria chiave occorre spedire un'e-mail al keyserver, con il comando ADD nel subject. Nel corpo del messaggio va copiata la propria chiave, estratta col comando <pgp -kxa> in modo da essere, come abbiamo visto, in formato ASCII. Ecco un'e-mail con cui si chiede di depositare una chiave:
=============================================================== To: pgp-public-keys@dsi.unimi.it From: lex@luthorcorp.com Subject: ADD --------------------------------------------------------------- -----BEGIN PGP PUBLIC KEY BLOCK----- Version: 2.6.3i Comment: PGP 2.x compatible mQCNAjTXBdgAAAEEANStJZjQZQpIE/0teO/Oo7Y52ESv7usdCrH3BSqLr14QGQpl +A+0z4UNlMYr+oNS8/xaNlriBdqWtrj8Ow3vydL12kdHjbtpNT180HlekU3+l263 /fKlLBXyOE1UWIRExvnVmX9qNd2xOszse+SwTzl9PICsJjxEvTt1dOqQZTMhAAUR tB9MZXggTHV0aG9yIDxsZXhAbHV0aG9yY29ycC5jb20+iQCVAgUQNNcF2Tt1dOqQ ZTMhAQGUYAP/c+iZSKAZ4juy+cB/H5PdeUSp14NYn8KkAs84tgq+dscG0EQB4vRa v5ZOkcZTARnV3EU0tEVb+Ube7TSfSjPugD4JEe+/uIRJgJhbfZXbh3uBngLNHshn NgWBT9/RCBELwvjAv17xu3chhL0xTIq7GNpcy6iJies/6GGndUc2pwg= =LWqw -----END PGP PUBLIC KEY BLOCK----- ================================================================
Per altre informazioni sulle funzioni di un keyserver, si può inviare allo stesso un'e-mail con scritto HELP nel subject della stessa.
Nota 1: È più semplice utilizzare inizialmente come user ID il nome o l'alias con cui si cambiare lo user ID o di aggiungerne altri alla propria coppia di chiavi o ancora di creare tante coppie di chiavi quante sono le identità che si assumono in rete. torna al testo
Nota 2: Bisogna tenere presente che il PGP nella digitazione della passphrase è sensibile alla differenza fra maiuscole e minuscole. Se ad esempio si sceglie come passphrase "yuk yuk", quando poi il PGP chiederà di digitare la propria passphrase per decrittare un messaggio, se si digiterà "Yuk yuk" si otterrà solo il fatidico messaggio: "Error: Bad pass phrase". torna al testo
Nota 3 :Un consiglio da amico contro la sfiga pura è: salva i keyring su dischetto prima di mandare in giro la tua chiave pubblica. E dopo che li hai salvati, ricorda di salvarli di nuovo periodicamente, perché così: A) quando prima o poi qualcosa andrà a puttane sull'hard disk e toccherà reinstallare anche il PGP, non dovrai far altro che sovrascrivere i nuovi keyring con quelli salvati su dischetto. In questo modo non hai bisogno di doverti fare una nuova coppia di chiavi, che è sempre un po' un casino (consulta la documentazione per la procedura di revoca di una chiave) e non dovrai cercare o farti rimandare di nuovo le chiavi pubbliche nel frattempo accumulate, che è sempre un po' una rottura per te e per il prossimo. B) se giri per il mondo e stai a casa di un amico che ha un PC e il PGP, puoi usare le tue chiavi dal dischetto senza dover reinstallare nulla (vedi comunque la documentazione del PGP a proposito). Naturalmente bisogna fidarsi abbastanza dell'amico ed è meglio evitare, in generale, di battere la propria passphrase in ambienti non sicuri, come ad esempio le reti locali delle università o delle ditte, dove possono girare più o meno legalmente dei programmi chiamati "sniffer" che leggono tutto quello che passa attraverso la rete, fra cui anche la tua chiave e la tua passphrase. Ma questo rientra in considerazioni più generali di sicurezza... torna al testo
Nota 4: Per crittare ciò che si vuole tenere riservato sul proprio hard disk o archiviare "solo per i propri occhi", è consigliabile l'uso dell'opzione <pgp -c> che non implica l'utilizzo della doppia chiave ma solo di una passphrase. Si occupa così anche in assoluto il minimo spazio su disco ed è probabilmente il tipo di crittazione più invulnerabile consentita dal PGP. Come al solito, per maggiori informazioni è meglio leggere la documentazione che accompagna il programma. torna al testo
Nota 5: Esiste il parametro <-o> che consente di creare un file crittato in una directory diversa da quella di default e anche di indicare per il file crittato un nomefile diverso da quello di default. torna al testo
Nota 6: È possibile configurare il file config.sys affinché il PGP crei sempre file crittati in formato ASCII, senza bisogno di digitare il parametro -a ogni volta che si desidera un armor. La scelta di quale settaggio usare di default è squisitamente personale. torna al testo
Nota 7: Il meccanismo delle certificazioni (trattato nel precedente capitolo) è piuttosto complesso ma è anche estremamente significativo; tuttavia una sua dettagliata trattazione uscirebbe dai propositi di questa guida introduttiva all'uso del PGP. Chiunque desideri approfondire l'argomento, può sfruttare l'abbondante e dettagliata documentazione che accompagna il pacchetto del software. torna al testo
Nota 8: La digitazione del comando <pgp -kv> senza ulteriori parametri provoca la visualizzazione di tutte le chiavi contenute nel pubring.pgp, il che può essere un problema quando sono molte. In questo caso si può digitare <pgp -kv | more> per visualizzare una schermata alla volta. torna al testo
Nota 9: Alcune analisi molto sofisticate hanno smentito la convinzione diffusa ed esposta, per motivi di semplicità, nelle righe precedenti: in realtà il fingerprint non identifica in modo assolutamente univoco una chiave pubblica, in quanto è tecnicamente possibile "pilotare" la creazione di una chiave pubblica affinchè questa presenti un certo fingerprint stabilito a priori (magari proprio quello di una chiave già esistente che si vuole "clonare"). Lo stesso discorso vale per il key ID della chiave. L'unico modo sicuro per identificare una chiave in modo univoco pare pertanto essere quello di verificare contemporaneamente fingerprint, key ID e dimensione della chiave (in quanto nella creazione di una chiave con fingerprint "pilotato" si perde il controllo sulla sua dimensione in bit). Si tratta di una delle questioni che rappresentano probabilmente lo stato dell'arte nella ricerca di punti deboli nel PGP. torna al testo