GPG parte 1 – Generare una chiave

In questo articolo verrà presentato il software GPG/PGP, verrà spiegato come generare una chiave in un ambiente Linux e come registrarla su un key server. Questo è la prima parte di una serie di articoli che spiegano il funzionamento di GPG.

Parte 2: Criptare e decriptare un messaggio con GPG

Parte 3: Importare/esportare chiavi in GPG

Innanzitutto GPG è un software che implementa lo standard OpenPGP, e dunque utilizza un sistema di crittografia a chiave pubblica, anche detta crittografia asimmetrica. E’ possibile trovare una spiegazione dettagliata della crittografia asimmetrica su wikipedia:

http://it.wikipedia.org/wiki/Crittografia_asimmetrica

Fondamentalmente con questa tipologia di algoritmi entrambe le persone coinvolte nella comunicazione devono disporre di 2 chiavi, una pubblica e una privata. La chiave pubblica, come dice il nome, deve essere distribuita pubblicamente, mentre deve restare assolutamente segreta la chiave privata. Lo schema di funzionamento di un algoritmo asimmetrico è quello mostrato nella figura seguente.

Crittografia_asimmetrica_schema
Funzionamento di un algoritmo di crittografia asimmetrica.

GPG inoltre permette anche di firmare i messaggi, e il funzionamento può essere visto nella figura sotto.

digitalsignatures
Funzionamento di firma digitale unita alla cifratura del messaggio.

Dunque per poter inviare un messaggio questo deve essere firmato con la propria chiave privata e criptato con la chiave pubblica del destinatario. In generale, per poter usare correttamente GPG dobbiamo tenere sempre a mente questi schemi, altrimenti presto o tardi probabilmente faremo confusione con le chiavi.

Dopo aver installato il software nella propria distribuzione e aver visto come funziona un algoritmo di cifratura asimmetrico, è possibile passare alla creazione della chiave.

Generare una chiave GPG

Da shell dobbiamo digitare:

# gpg --gen-key

Dunque ci viene richiesto quale algoritmo di cifratura deve essere usato per la generazione della chiave:

Please select what kind of key you want:
(1) RSA and RSA (default)
(2) DSA and Elgamal
(3) DSA (sign only)
(4) RSA (sign only)
Your selection? 1

Possiamo scegliere tranquillamente l’opzione default.

Poi ci viene richiesta la dimensione della chiave:

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048)

Direi che la dimensione base (2048) è più che sufficiente.

Poi ci viene richiesto il periodo di validità della chiave:

Please specify how long the key should be valid.
0 = key does not expire
<n> = key expires in n days
<n>w = key expires in n weeks
<n>m = key expires in n months
<n>y = key expires in n years
Key is valid for? (0)

In questo caso se la chiave verrà usata per lo scambio di informazioni personali, possiamo tranquillamente non farla scadere mai, mentre se verrà usata per lo scambio di informazioni sensibili e/o professionali allora è bene impostare un intervallo temporale adeguato (1 anno, 6 mesi, 1 mese, …).

Poi sono richieste alcune informazioni personali:

You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"

—————————————
Real name: Paolino Paperino
Email address: paolino.paperino@paperopoli.com
Comment: My GPG key

quindi ci viene mostrato il riepilogo con le informazioni immesse:

You selected this USER-ID:
"Paolino Paperino (My GPG key) <paolino.paperino@paperopoli.com>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit?

Se i dati inseriti sono corretti possiamo digitare “O” per proseguire.

Adesso ci verrà richiesta la passphrase, che dovrà essere sufficientemente robusta:

You need a Passphrase to protect your secret key.
Enter passphrase:

E’ importante, anzi fondamentale, scegliere la passphrase attentamente, perché da essa dipende la sicurezza della chiave GPG! Nel caso in cui dovessimo dimenticarcela non potremo più leggere/inviare messaggi cifrati, mentre se dovesse essere crackata lo scambio di testi cifrati con GPG non sarebbe più sicuro.

Dunque verrà generata la chiave GPG unica:

gpg: key 257BAFD8 marked as ultimately trusted
public and secret key created and signed.

————————————–
gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0 valid: 2 signed: 0 trust: 0-, 0q, 0n, 0m, 0f, 2u

————————————–
pub 2048R/257BAFD8 2012-09-05
Key fingerprint = A197 6014 A02F 6AFD 4007 5C02 FCB1 2276 257B AFD8
uid Paolino Paperino (My GPG key) <paolino.paperino@paperopoli.com>
sub 2048R/D156C60B 2012-09-05

Controllare la chiave

Dopo aver generato una nuova chiave, è buona cosa controllarne i dati:

# gpg --list-key
/root/.gnupg/pubring.gpg
------------------------
pub 2048R/257BAFD8 2012-09-05
uid Paolino Paperino (My GPG key) <paolino.paperino@paperopoli.com>
sub 2048R/D156C60B 2012-09-05

dove possiamo vedere i dati fondamentali:

  • Key ID: 257BAFD8
  • Real Name: Paolino Paperino
  • E-mail: paolino.paperino@paperopoli.com
  • Expiration date: 2012-09-05

Generare una chiave pubblica

Il prossimo step è quello di salvare la chiave pubblica GPG per poi poterla inviare ad amici o colleghi, in modo che loro possano inviarci messaggi cifrati. Per esportare la chiave pubblica in un file la sintassi da usare è la seguente:

# gpg --armor --output GPG_public_key --export Real Name

oppure

# gpg --armor --output GPG_public_key --export E-mail

oppure

# gpg --armor --output GPG_public_key --export Key ID

E’ da notare che il risultato dei 3 comandi precedenti è identico.

Nel nostro esempio i comandi precedenti diventeranno:

# gpg --armor --output GPG_public_key --export Paolino Paperino
# gpg --armor --output GPG_public_key --export paolino.paperino@paperopoli.com
# gpg --armor --output GPG_public_key --export 257BAFD8

Inviare la chiave ad un key server

Infine, l’ultimo passo (facoltativo) è di inviare la chiave pubblica ad un key server, un server che raccoglie le chiavi pubbliche. Inserendo la chiave in un key server, chiunque voglia inviarci un messaggio cifrato non avrà il bisogno di chiedere a noi la chiave, ma potrà semplicemente cercarla sul server. Il comando da eseguire è questo:

# gpg --send-keys --keyserver url_server Key ID

Per il nostro esempio abbiamo:

# gpg --send-keys --keyserver hkp://subkeys.pgp.net 257BAFD8

Le altre parti sono disponibili a questi link:

Parte 2: Criptare e decriptare un messaggio con GPG

Parte 3: Importare/esportare chiavi in GPG

roghan

GPG parte 3 – Importare/esportare chiavi

Ho in mente di scrivere una serie di articoli sul funzionamento di GPG (GNU Privacy Guard), per poi raccoglierli all’interno di una guida (magari anche in inglese). Sul web si trovano facilmente guide e howto su GPG e su come usarlo da shell, ma ho la necessità di creare la mia propria documentazione, da usare come punto di riferimento anche in futuro.

Per ora vediamo come fare il backup e il ripristino di una chiave GPG . Tale necessità può esserci se vogliamo usare GPG su sistemi diversi usando ovviamente le stesse chiavi di cifratura, come ad esempio se cifriamo un messaggio con il pc dell’ufficio e dobbiamo decifrarlo con il pc di casa. […]

Ho in mente di scrivere una serie di articoli sul funzionamento di GPG (GNU Privacy Guard), per poi raccoglierli all’interno di una guida (magari anche in inglese). Sul web si trovano facilmente guide e howto su GPG e su come usarlo da shell, ma ho la necessità di creare la mia propria documentazione, da usare come punto di riferimento anche in futuro.

Per ora vediamo come fare il backup e il ripristino di una chiave GPG . Tale necessità può esserci se vogliamo usare GPG su sistemi diversi usando ovviamente le stesse chiavi di cifratura, come ad esempio se cifriamo un messaggio con il pc dell’ufficio e dobbiamo decifrarlo con il pc di casa.

Backup/esportazione di una chiave GPG

Per prima cosa controlliamo le chiavi installate all’interno del sistema:

# gpg --list-keys
/root/.gnupg/pubring.gpg
-------------------------------
pub 2048R/9F508959 2012-07-03
uid Paolino Paperino <paolino.paperino@paperopoli.com>
sub 2048R/2C98FA15 2012-07-03
-------------------------------
pub 2048R/AB2C995F 2012-07-03
uid Zio Paperone <zio.paperone@paperopoli.com>
sub 2048R/D643E356 2012-07-03

Dunque dobbiamo scegliere la chiave di cui vogliamo fare il backup, per poi fare la copia della chiave pubblica e di quella privata. Nell’esempio le chiavi installate sono due: 9F508959 e DC2C775F. Per fare la copia rispettivamente della chiave pubblica e di quella privata la sintassi è la seguente (per maggior chiarezza userò i nomi completi delle opzioni, almeno dove possibile):

# gpg --armor --output <filename> --export <keyname>
# gpg --armor --output <filename> --export-secret-keys <keyname>

L’opzione armor permette di creare un output in caratteri ASCII, simile a questo

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.12 (GNU/Linux)mQENBE/1likBCACUfcgaiMfznrEQKXV4x0rPpixqEW+m8vXBF5I2BPuzeKUrB9Ot
YZhuZujuheLjj+Quh5rBFntGoPW3rO430Voq5/PJew54P5Smx6K09paB6pGbzmgk
...
INmtEZwlEvYMrINVOKbKXRk=
=8NiR
-----END PGP PUBLIC KEY BLOCK-----

Se l’opzione armor viene invece omessa, l’output prodotto sarà binario.

Supponendo di voler fare il backup della chiave 9F508959 dell’esempio, i comandi sono:

# gpg --armor --output GPG_public_key --export 9F508959
# gpg --armor --output GPG_secret_key --export-secret-keys 9F508959

Infine, per completare la fase di backup è consigliabile generare anche una chiave di revoca con questo comando:

# gpg --output <filename> --gen-revoke <keyname>

Nel caso dell’esempio, il comando precedente diventerebbe:

# gpg --output GPG_revoke_key --gen-revoke 9F508959

Dopo che le chiavi sono state salvate memorizziamo i relativi file in un supporto sicuro, e possibilmente mobile (CD, DVD, …) anziché all’interno dello stesso sistema in cui è installato GPG!

Ripristino/importazione di una chiave GPG

Se vogliamo ripristinare una chiave GPG, o ad esempio importarla su un nuovo sistema (dal pc dell’ufficio a quello di casa), il comando è il seguente:

# gpg --import <filename>

dove <filename> rappresenta il file contenente la chiave (pubblica o privata) precedentemente esportata. Riprendendo l’esempio precedente, i comandi necessari per importare le chiavi sono questi:

# gpg --import GPG_public_key
# gpg --import GPG_secret_key

roghan

GPG parte 2 – Criptare e decriptare un messaggio

Vediamo in questo articolo come criptare e decriptare un messaggio con GPG tramite shell.

GPG è un software che implementa lo standard OpenPGP, e dunque utilizza un sistema di crittografia a chiave pubblica, anche detto crittografia asimmetrica. E’ possibile trovare una spiegazione dettagliata della crittografia asimmetrica su wikipedia:

http://it.wikipedia.org/wiki/Crittografia_asimmetrica

Fondamentalmente con questa tipologia di algoritmi entrambe le persone coinvolte nella comunicazione devono disporre di 2 chiavi, una pubblica e una privata. La chiave pubblica, come dice il nome, deve essere distribuita pubblicamente, mentre deve restare assolutamente segreta la chiave privata. Lo schema di funzionamento di un algoritmo asimmetrico è questo […]

Vediamo in questo articolo come criptare e decriptare un messaggio con GPG tramite shell.

Se vogliamo inviare un messaggio criptato a Paolino Paperino tramite GPG, i passi da effettuare sono:

  1. chiedere a Paolino Paperino la sua chiave pubblica, o cercarla su un key server;
  2. importare la chiave pubblica di Paolino Paperino in GPG;
  3. criptare il messaggio;
  4. inviare il messaggio a Paolino Paperino.

Nel caso opposto, in cui vogliamo decriptare un messaggio ricevuto da Paolino Paperino, i passi sono:

  1. chiedere a Paolino Paperino la sua chiave pubblica, o cercarla su un key server;
  2. importare la chiave pubblica di Paolino Paperino in GPG;
  3. ricevere il messaggio da Paolino Paperino;
  4. decriptare il messaggio.

Vediamo adesso prima i passi per criptare e inviare un messaggio, e poi quelli per decriptare un messaggio.

Criptare e inviare un messaggio

1 – Ottenere la chiave pubblica di una persona

Per ottenere la chiave pubblica di qualcuno, la soluzione migliore è chiederla al diretto interessato, ad esempio tramite mail. La chiave può essere salvata/inviata come un file testuale con una forma simile alla seguente:

-----BEGIN PGP PUBLIC KEY BLOCK-----Version: GnuPG v1.4.10 (GNU/Linux)hQLNYbY1gO6GWuWNqoQsRBACBRP2QTKHM+SOQIqjqJcaGAj/ckLf8/vPseiSuzQtQqBTgHRnRu3qQhS9+rfMlnm3v3nbrJH8+qhdqZAZLklKCsyDfBeevtNRSHyKsxNUlhFlkvu7ZHr/T4OsQZT5weJ4YSsYi7JaHJaNbOu4J6R63FfwCg5kgeyY/8nQmtixlpKdCWSOQIqjqJcaGAj/ckLf8/vPs8wbA//A7JUfFBxMWAR2bEkLI90i+4ZnKBlZ0fx1NZTiISItikUOVSp+oAn24mV3xBLNYbY1gO6GWuWNqoQfDB=a9d8m30Pw—–END PGP PUBLIC KEY BLOCK—–

Alternativamente, se la persona ha pubblicato su un key server la propria chiave, è possibile recuperarla con uno di questi 3 comandi (il risultato è lo stesso):

# gpg --search-keys --keyserver hkp://server Mail_address
# gpg --search-keys --keyserver hkp://server "Person Name"
# gpg --search-keys --keyserver hkp://server key_ID

Ad esempio possiamo cercare la chiave di Paolino Paperino:

# gpg --search-keys --keyserver hkp://subkeys.pgp.net "Paolino Paperino"

————————————————————————————–
gpg: searching for "Paolino Paperino" from hkp server subkeys.pgp.net
(1) Paolino Paperino <paolino.paperino@paperopoli.com>
2048-bit RSA key, ID AC3C885F, created 2012-07-03
Keys 1-1 of 1 for "Paolino Paperino". Enter number(s), N)ext, or Q)uit >

La ricerca della chiave pubblica di una persona deve essere effettuata solo la prima volta, a meno che la persona non cambi la propria chiave.

2 – Importare la chiave pubblica

Adesso dobbiamo importare all’interno di GPG la chiave pubblica della persona. Nel caso in cui la chiave sia stata recuperata tramite un key server, è possibile importarla usando uno di questi 3 comandi (il risultato è lo stesso):

# gpg --recv-keys --keyserver hkp://server Mail_address
# gpg --recv-keys --keyserver hkp://server "Person Name"
# gpg --recv-keys --keyserver hkp://server key_ID

Se invece la chiave pubblica della persona è su un file (ad esempio inviato tramite mail), è possibile importarla con questo comando:

# gpg --import public_key.txt

In entrambi i casi, dopo aver importato la chiave è bene effettuare una verifica delle chiavi importate in GPG con il comando:

# gpg --list-keys

Tornando all’esempio, nel caso in cui vogliamo importare la chiave pubblica di Paolino Paperino che si trova nel file PaolinoPaperino_public_key.txt, i comandi sono:

# gpg --import PaolinoPaperino_public_key.txt
# gpg --list-key/home/xxx/.gnupg/pubring.gpg
-------------------------------
pub 2048R/AC3C885F 2012-07-03
uid Paolino Paperino <paolino.paperino@paperopoli.com>
sub 2048R/C624E359 2012-07-03

oppure, se la chiave è presente su un key server usiamo il comando:

# gpg --recv-keys --keyserver hkp://subkeys.pgp.net "Paolino Paperino"

Come il passo precedente, anche questo deve essere effettuato solo la prima volta. Ogni volta che poi dovremo criptare/decriptare un messaggio, GPG andrà a cercare la chiave corretta tra quelle importate al suo interno.

3 – Criptare un messaggio

Dopo aver importato la chiave pubblica di una persona all’interno di GPG, possiamo procedere a criptare e firmare un messaggio in questo modo:

# gpg --armor --recipient "Person Name" --sign --encrypt messagge.txt

oppure specificando il file in cui verrà salvato il messaggio criptato:

# gpg --output final_message.txt --armor --recipient "Person Name" --sign --encrypt messagge.txt

Analizziamo le opzioni utilizzate:

  • output è opzionale e permette di indicare il file in cui verrà salvato il messaggio criptato;
  • armor è opzionale e serve per produrre un messaggio criptato usando la codifica ASCII, altrimenti senza tale opzione viene prodotto un file binario;
  • recipient è un’opzione obbligatoria e identifica il destinatario del messaggio, dunque chi sarà in grado di decriptare il messaggio;
  • sign è opzionale e firma il messaggio;
  • encrypt è ovviamente obbligatoria e cripta finalmente il messaggio.

Veniamo all’esempio. Se vogliamo inviare un messaggio criptato a Paolino Paperino, il comando necessario sarà:

# gpg --armor --recipient "Paolino Paperino" --sign --encrypt messaggio_da_paperone.txt

Il messaggio che viene prodotto dal comando precedente può poi essere inviato al destinatario.

4 – Inviare un messaggio criptato

Dopo aver criptato il messaggio, possiamo inviarlo alla nostra destinazione.

Nel caso in cui abbiamo scelto l’opzione armor, il testo criptato avrà una forma simile a questa:

-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.2.10
hQEMAyAXkJC2I+NYAQf/dAPmS9pAawmTsTMxuN3qW4YSjup2E9GZZI8x4ikwAIrh
poPumljoUR5tqsf5+xvtrOpamY3qaTeUGCadtQiqCod2zrfZEA7iLUtcO2i47yuK
VCT7yY1SKWhtAvElrkd48k0CY8HMMRpGWMdXlvfnZNxl3lEo2F1oIH45xsUo9HJ8
9z0e0Jlm5oe3KCMSOPDqIQRvAeWHSruyeLtyUuaCWsdu9JaSEd1j886wxCbbCzrp
r2H6MPmd35gpthoIR8QjbAF7bzpnltXRZrs4Aex31o4YrjW4Ns/S2w==
=Yxjk
-----END PGP MESSAGE-----

Per trasmettere il testo criptato al destinatario è sufficiente copiarlo all’interno della mail da inviare.

Ricevere e decriptare un messaggio

1 – Ottenere la chiave pubblica di una persona

Il procedimento è lo stesso del punto 1 precedente, e deve essere effettuato solo la prima volta.

2 – Importare la chiave pubblica

Il procedimento è lo stesso del punto 2 precedente, e deve essere effettuato solo la prima volta.

3 – Ricevere un messaggio criptato

Un messaggio criptato può essere ricevuto tramite gli stessi mezzi dei messaggi in chiaro tradizionali, ad esempio tramite mail. Ricordo che un messaggio criptato ha solitamente una forma di questo tipo:

-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.2.10
hQEMAyAXkJC2I+NYAQf/dAPmS9pAawmTsTMxuN3qW4YSjup2E9GZZI8x4ikwAIrh
poPumljoUR5tqsf5+xvtrOpamY3qaTeUGCadtQiqCod2zrfZEA7iLUtcO2i47yuK
VCT7yY1SKWhtAvElrkd48k0CY8HMMRpGWMdXlvfnZNxl3lEo2F1oIH45xsUo9HJ8
9z0e0Jlm5oe3KCMSOPDqIQRvAeWHSruyeLtyUuaCWsdu9JaSEd1j886wxCbbCzrp
r2H6MPmd35gpthoIR8QjbAF7bzpnltXRZrs4Aex31o4YrjW4Ns/S2w==
=Yxjk
-----END PGP MESSAGE-----

4 – Decriptare un messaggio

Nell’ultimo passo dobbiamo decriptare il messaggio ricevuto, e il comando è questo:

# gpg --output message.txt --decrypt encrypted_message.txt

Il comando è piuttosto esplicativo in quando devono essere specificati solamente il file di output, in cui verrà memorizzato il file decriptato, e il messaggio criptato ricevuto.

Con il nostro esempio, se vogliamo decriptare un messaggio dobbiamo eseguire:

# gpg --output message_from_Paperino.txt --decrypt encrypted_message_from_Paperino.txt
---------------------------------------------
You need a passphrase to unlock the secret key for
user: "Paolino Paperino <paolino.paperino@paperopoli.com>"
2048-bit RSA key, ID AC3C885F, created 2012-07-03
Enter passphrase:

roghan