rigacci.org

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Utilizzare GnuPG ======

Come usare GnuPG con mutt: **[[mutt_gnupg_howto|Mutt GnuPG HOWTO]]**.

===== Creazione della coppia chiavi pubblica/privata =====

<code>
gpg --full-generate-key
</code>

<code>
Please select what kind of key you want:
RSA and RSA
RSA keys may be between 1024 and 4096 bits long.
Requested keysize is 2048 bits
Key is valid for? (0) 3y
Real name: Niccolo Rigacci
Email address: niccolo@rigacci.org
</code>

La chiave privata (protetta dalla passphrase) viene memorizzata in ''**~/.gnupg/secring.gpg**'', le chiavi pubbliche  in ''**~/.gnupg/pubring.gpg**''.

Per pubblicare la propria chiave (la parte pubblica) su un server pubblico:

<code>
gpg --keyserver pgp.key-server.io --send-keys 58F28BB5
</code>

Questi i comandi per:

  * Recuperare e installare nel portachiavi locale (''pubring.gpg'') una chiave pubblica. Si indica il key ID e si usa il server hkp (Horowitz Key Protocol) di default **subkeys.pgp.net**.
  * Listare le chiavi pubbliche dal porachiavi locale (''pubring.gpg'')
  * Listare le chiavi private dal portachiavi locale (''secring.gpg'')

<code>
gpg --recv-keys 0xC9C40C31
gpg --list-keys
gpg --list-secret-keys
</code>

===== Pubblicazione su keys.openpgp.org =====

Sul server **[[https://keys.openpgp.org/|keys.openpgp.org]]** è possibile pubblicare e cercare chiavi pubbliche. Esiste una procedura web che consente di caricare il file ASCII della chiave pubblica. Per impostazione predefinita non viene pubblicato l'indirizzo di posta elettronica associato, nel caso si voglia rendere trovabile la propria chiave cercandola per email, è necessario eseguire la procedura di verifica con invio di conferma allo stesso indirizzo email.


===== Firmare o criptare un documento =====

Questi i comandi per firmare in documento in chiaro, verificare la firma, criptare un documento in formato armor:

<code>
gpg --clearsign sample.txt
gpg --verify sample.txt.asc
gpg --encrypt --armor sample.txt
</code>

Viene creato il file ''**sample.txt.asc**''.


===== Criptare o firmare una mail con mutt =====

Scrivere la mail normalmente, nel menu di composizione/spedizione premere il tasto **p**, quindi scegliere ''**(e)ncrypt**'' oppure ''**(s)ign**''. Al momento dell'invio (tasto **y**) in caso di encrypt si potrà scegliere la chiave del destinatario da utilizzare.

===== Leggere una mail criptata =====

Se riceviamo un messaggio criptato con la nostra chiave pubblica, questo viene visualizzato più o meno così:

<file>
-----BEGIN PGP MESSAGE-----
Charset: ISO-8859-15
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

hQIOA0tM8wRUc4O3EAgAp64dASpkzHFQCTVkqw7678SMGUrzGhuarslU/U2UyE6W
nIOUycrRQ3gon1qcQJ9lorMlSO0r+dKewuAd36RTDJF4ilSsgK8ewisH5FlatF9H
...
NNNvDbscjyR0X7L7ksJ2BwnYxSguaQT4ONOnLGlEi0Y4SjTOZqqLTa2sCcY6ox5m
sQDexp+DrD1EMmxhapRRO7VAr/fj7OJ/RDrG
=JwLq
-----END PGP MESSAGE-----
</file>

Si deve premere ''**Esc-P**'' (p maiuscola), quindi immettere la password che protegge il nostro portachiavi. A questo punto il messaggio viene decriptato (solo in RAM) e mostrato a video.

Se si effettua un **reply al messaggio**, mutt tenta di criptarlo con la chiave pubblica del mittente, cercandola nel portachiavi. Se la trova il messaggio spedito sarà criptato così come la copia locale (pertanto non sarà possibile rileggerlo).







===== Scambio delle chiavi =====

Si deve vedere l'ID della nostra chiave, quindi esportare in formato ASCII-armored la chiave pubblica:

<code>
$ gpg --list-keys
/home/niccolo/.gnupg/pubring.gpg
--------------------------------
pub   1024D/970EC418 2005-07-13 [expires: 2007-07-13]
uid                  Niccolo Rigacci <niccolo(a)rigacci.org>

gpg --armor --export 970EC418 > niccolo_pub.key
</code>

Il nostro corrispondente può importare la chiave nel proprio keyring con il comando:

<code>
gpg -i --import niccolo_pub.key
</code>

Importante lo switch **''%%-i%%''** che mostra le informazioni contenute nella chiave e chiede conferma prima di inserirla nel portachiavi.

Esistono dei server pubblici dedicati allo scambio delle chiavi (pubbliche). Ad esempio con **[[http://pgp.key-server.io/|pgp.key-server.io]]** oppure **[[https://pgp.mit.edu/|pgp.mit.edu]]** l'upload della chiave ASCII-armored viene fatta via web, poi si può fare la ricerca per parola chiave (nome, cognome, dominio mail, ...).

Per installare nel proprio portachiavi una chiave presa dal server in questione si può prelevare il file ASCII-armored ed effettuare l'''**%%--import%%**'', uppure usare l'opzione ''**%%--recv-keys%%**'' vista in precedenza per prelevare la chiave direttamente via rete. Non è necessario neanche specificare l'opzione ''**%%--keyserver%%**'', forse perché si tratta dello stesso circuito **pgp.net**?

Esempio: partendo da %%wwwkeys.eu.pgp.net%%  si viene rediretti su **[[http://minsky.surfnet.nl/|minsky.surfnet.nl]]**. Si effettua una ricerca per parola chieve, si identifica la **keyID** desiderata e la si importa nel proprio keyring:

<code>
gpg --keyserver minsky.surfnet.nl --recv-keys 111FA57C
</code>

===== Copia di una chiave privata =====

Con questa procedura si può copiare una chiave privata da un host ad un altro. Per prima cosa si elencano le chiavi private e si prende nota dell'ID della chiave da esportare:

<code>
gpg --list-secret-keys
</code>

Quindi si salva in un file il **PRIVATE KEY BLOCK** (quasi certamente la chiave privata è protetta da password, che viene chiesta durante la procedura di esportazione):

<code>
touch private.key
chmod 640 private.key
gpg --armor --export-secret-keys 8364FCC486877E37A39B7D5D01526646275E281D > private.key
</code>

Dopo aver copiato il file sul nuovo host, si esegue (viene chiesta nuovamente la password che protegge la chiave):

<code>
gpg --import private.key
</code>

La chiave privata viene salvata nel keyring, si può verificare con **%%gpg --list-secret-keys%%**. La chiave resta **cifrata** con la password che aveva in origine.
===== Cifrare/decifrare un file da riga di comando =====

<code>
gpg --encrypt <filename>
gpg --decrypt <filename>.gpg
</code>

Vengono chiesti gli ID dei destinatari. Per ogni destinatario aggiunto il file cresce di pochi byte. 

Per produrre un file criptato, ma in formato ASCII:

<code>
gpg --armor --encrypt <filename>
gpg --decrypt <filename>.asc
</code>

===== Verificare la firma di un file =====

Bisogna prima importare la relativa chiave pubblica di chi ha firmato il file e poi verificare il file rispetto alla firma. Esempio con l'archivio dei sorgenti kernel Linux:

<code>
gpg --keyserver wwwkeys.pgp.net --recv-keys 0x517D0F0E
gpg --verify linux-2.6.15.tar.bz2.sign linux-2.6.15.tar.bz2
gpg: Signature made Tue 03 Jan 2006 06:19:03 AM CET using DSA key ID 517D0F0E
gpg: Good signature from "Linux Kernel Archives Verification Key <ftpadmin@kernel.org>"
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: C75D C40A 11D7 AF88 9981  ED5B C86B A06A 517D 0F0E
</code>

Il messaggio di warning significa che la chiave è stata ottenuta senza seguire una //trust path// opportuna, infatti è stata direttamente scaricata dal web e messa nel portachiavi.

===== Firmare una chiave =====

Firmare la chiave di qualcuno (**[[http://www.gnupg.org/howtos/it/gpg-party.html|GnuPG Keysigning Party HOWTO]]**) significa anzitutto firmarla e quindi pubblicare il fatto di averla firmata:

<code>
gpg --sign-key <Key_ID>
gpg --keyserver <keyserver> --send-key <Key_ID>
</code>

Durante i Keysigning Party si prende nota della //key ID// e della //public key fingerprint// che ci comunica una persona fidata, questo perché la fingerprint è più mageggevole della chiave intera.

Con altri mezzi si recupera l'intera chiave pubblica, ad esempio cercandola per key ID da un key server e salvandola in un file. Quindi si verifica che la fingerprint sia davvero quella e se è il caso si importa nel portachiavi:

<code>
gpg --with-fingerprint <filename_pub.key>
gpg -i --import <filename_pub.key>
</code>


Per vedere la fingerprint delle chiavi in nostro possesso:

<code>
gpg --fingerprint
</code>

===== Ricerca di una chiave pubblica =====

Si dovrebbe poter interrogare dei server pubblici per cercare la chiave pubblica di una persona, ad esempio **[[http://pgp.key-server.io/]]** oppure **[[http://hkps.pool.sks-keyservers.net/]]**. Nel risultato vengono mostrate tutte le chiavi, anche quelle eventualmente scadute o revocate.

{{pgp.key-server.io.png?600|Search result on pgp.key-server.io}}

Nella schermata sopra si vede ad esempio che esiste la chiave **275E281D** scaduta il **2018-09-17**, la chiave più recente invece è la **58F28BB5** che scade il **2021-09-16**.