110.3 Lezione 2

110.3 Lezione 2

Certificazione:

LPIC-1

Versione:

5.0

Argomento:

110 Sicurezza

Obiettivo:

110.3 Proteggere i dati con la crittografia

Lezione:

2 di 2

Introduzione

Nella lezione precedente abbiamo imparato come usare OpenSSH per crittografare le sessioni di login remoto così come ogni altro successivo scambio di informazioni. Ci possono essere altri scenari in cui si può desiderare di criptare file o email in modo che raggiungano il loro destinatario in modo sicuro e al riparo da occhi indiscreti. Potresti anche aver bisogno di firmare digitalmente quei file o messaggi per evitare che vengano manomessi.

Un ottimo strumento per questo tipo di usi è il GNU Privacy Guard (anche noto come GnuPG o semplicemente GPG); implementazione libera e open source del proprietario Pretty Good Privacy (PGP). GPG usa lo standard OpenPGP come definito dall'OpenPGP Working Group dell'Internet Engineering Task Force (IETF) presente nell' RFC 4880. In questa lezione scopriremo i fondamenti del GNU Privacy Guard.

Effettuare la Configurazione di Base, Utilizzare ed Eseguire Attività di Revoca con GnuPG

Proprio come per SSH, il meccanismo sottostante a GPG è quello della crittografia asimmetrica o crittografia a chiave pubblica. Un utente genera una coppia di chiavi che è composta da una chiave privata e una chiave pubblica. Le chiavi sono legate matematicamente in modo tale che ciò che è criptato da una può essere decriptato solo dall’altra. Affinché la comunicazione avvenga con successo, l’utente deve inviare la sua chiave pubblica al destinatario.

Configurazione e Uso di GnuPG

Il comando per lavorare con GPG è gpg. Puoi passargli una serie di opzioni per eseguire diversi compiti. Cominciamo generando una coppia di chiavi come utente carol. Userai il comando gpg --gen-key:

carol@debian:~$ gpg --gen-key
gpg (GnuPG) 2.2.12; Copyright (C) 2018 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

gpg: directory '/home/carol/.gnupg' created
gpg: keybox '/home/carol/.gnupg/pubring.kbx' created
Note: Use "gpg --full-generate-key" for a full featured key generation dialog.

GnuPG needs to construct a user ID to identify your key.

Real name:

(...)

Dopo averti informato, tra le altre cose, che la directory di configurazione ~/.gnupg e il tuo portachiavi pubblico ~/.gnugpg/pubring.kbx sono stati creati, gpg procede con il chiederti di fornire il tuo vero nome e l’indirizzo email:

(...)
Real name: carol
Email address: carol@debian
You selected this USER-ID:
    "carol <carol@debian>"

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

Se sei d’accordo con la USER-ID risultante e premi O, ti verrà chiesta una passphrase (si raccomanda di metterne una abbastanza complessa):

┌──────────────────────────────────────────────────────┐
│ Please enter the passphrase to                       │
│ protect your new key                                 │
│                                                      │
│ Passphrase:  │

(...)

Verranno visualizzati alcuni ulteriori messaggi che informeranno della creazione di altri file e delle chiavi stesse, quindi avrai finito con il processo di generazione delle chiavi:

(...)
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
gpg: /home/carol/.gnupg/trustdb.gpg: trustdb created
gpg: key 19BBEFD16813034E marked as ultimately trusted
gpg: directory '/home/carol/.gnupg/openpgp-revocs.d' created
gpg: revocation certificate stored as '/home/carol/.gnupg/openpgp-revocs.d/D18FA0021F644CDAF57FD0F919BBEFD16813034E.rev'
public and secret key created and signed.

pub   rsa3072 2020-07-03 [SC] [expires: 2022-07-03]
      D18FA0021F644CDAF57FD0F919BBEFD16813034E
uid                      carol <carol@debian>
sub   rsa3072 2020-07-03 [E] [expires: 2022-07-03]

Ora puoi vedere che cosa c’è dentro la directory ~/.gnupg (la directory di configurazione di GPG):

carol@debian:~/.gnupg$ ls -l
total 16
drwx------ 2 carol carol 4096 Jul  3 23:34 openpgp-revocs.d
drwx------ 2 carol carol 4096 Jul  3 23:34 private-keys-v1.d
-rw-r--r-- 1 carol carol 1962 Jul  3 23:34 pubring.kbx
-rw------- 1 carol carol 1240 Jul  3 23:34 trustdb.gpg

Spieghiamo l’uso di ogni file:

opengp-revocs.d

Il certificato di revoca che è stato creato insieme alla coppia di chiavi è conservato qui. I permessi su questa directory sono abbastanza restrittivi poiché chiunque abbia accesso al certificato potrebbe revocare la chiave (maggiori informazioni sulla revoca della chiave nella prossima sottosezione).

private-keys-v1.d

Questa è la directory che mantiene le vostre chiavi private, quindi i permessi sono restrittivi.

pubring.kbx

Questo è il tuo portachiavi pubblico. Memorizza le tue e qualsiasi altra chiave pubblica importata.

trustdb.gpg

"Il database della fiducia". Riguarda il concetto di Web of Trust (che esula dallo scopo di questa lezione).

Note

L’arrivo di GnuPG 2.1 ha portato alcuni cambiamenti significativi, come la scomparsa dei file secring.gpg e pubring.gpg in favore rispettivamente di private-keys-v1.d e pubring.kbx.

Una volta che la tua coppia di chiavi è stata creata, puoi vedere le tue chiavi pubbliche con gpg --list-keys; mostrerà il contenuto del tuo portachiavi pubblico:

carol@debian:~/.gnupg$ gpg --list-keys
/home/carol/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2020-07-03 [SC] [expires: 2022-07-03]
      D18FA0021F644CDAF57FD0F919BBEFD16813034E
uid           [ultimate] carol <carol@debian>
sub   rsa3072 2020-07-03 [E] [expires: 2022-07-03]

La stringa esadecimale D18FA0021F644CDAF57FD0F919BBEFD16813034E è la tua impronta della chiave pubblica.

Note

Oltre alla USER-ID (carol nell’esempio), c’è anche la KEY-ID. Il KEY-ID consiste nelle ultime 8 cifre esadecimali dell’impronta della tua chiave pubblica (6813 034E). Puoi controllare il tuo fingerprint della chiave con il comando gpg --fingerprint USER-ID.

Distribuzione e Revoca della Chiave

Ora che hai la tua chiave pubblica, dovrai salvarla (cioè esportarla) in un file per renderla disponibile ai futuri destinatari. Essi potranno allora usarla per criptare i file o i messaggi destinati a te (poiché sei l’unico in possesso della chiave privata, sarei anche il solo a poterli decriptare e leggere). Allo stesso modo, anche i tuoi destinatari la useranno per decifrare e verificare i tuoi messaggi/file cifrati o firmati. Il comando da usare è gpg --export seguito dal USER-ID e da un reindirizzamento al nome del file di output di tua scelta:

carol@debian:~/.gnupg$ gpg --export carol > carol.pub.key
carol@debian:~/.gnupg$ ls
carol.pub.key  openpgp-revocs.d  private-keys-v1.d  pubring.kbx  trustdb.gpg
Note

Passando l’opzione -a o --armor a gpg --export (per esempio: gpg --export --armor carol > carol.pub.key) si creerà un output ASCII "blindato" (invece del formato binario OpenPGP predefinito) che può essere tranquillamente spedito via email.

Come già detto, devi ora inviare il file di chiave pubblica (carol.pub.key) al destinatario con cui vuoi scambiare informazioni. Per esempio, mandiamo il file della chiave pubblica a ina sul server remoto halof usando scp (secure copy):

carol@debian:~/.gnupg$ scp carol.pub.key ina@halof:/home/ina/
Enter passphrase for key '/home/carol/.ssh/id_ecdsa':
carol.pub.key                                                                                         100% 1740   775.8KB/s   00:00
carol@debian:~/.gnupg$

ina è ora in possesso di carol.pub.key. La userà per criptare un file e inviarlo a carol nella prossima sezione.

Note

Un altro mezzo di distribuzione delle chiavi pubbliche è attraverso l’uso di un key server: si carica la propria chiave pubblica sul server con il comando gpg --keyserver keyserver-name --send-keys KEY-ID e gli altri utenti la ottengono (cioè la importano) con gpg --keyserver keyserver-name --recv-keys KEY-ID.

Chiudiamo questa sezione discutendo la revoca delle chiavi. La revoca delle chiavi dovrebbe essere usata quando le chiavi private sono state compromesse o ritirate. Il primo passo è creare un certificato di revoca passando a gpg l’opzione --gen-revoke seguita da USER-ID. Puoi far precedere a --gen-revoke l’opzione --output seguita da un nome di file di destinazione per salvare il certificato risultante in un file (invece di farlo stampare sullo schermo del terminale). I messaggi di output durante il processo di revoca sono abbastanza autoesplicativi:

sonya@debian:~/.gnupg$ gpg --output revocation_file.asc --gen-revoke sonya

sec  rsa3072/0989EB7E7F9F2066 2020-07-03 sonya <sonya@debian>

Create a revocation certificate for this key? (y/N) y
Please select the reason for the revocation:
  0 = No reason specified
  1 = Key has been compromised
  2 = Key is superseded
  3 = Key is no longer used
  Q = Cancel
(Probably you want to select 1 here)
Your decision? 1
Enter an optional description; end it with an empty line:
> My laptop was stolen.
>
Reason for revocation: Key has been compromised
My laptop was stolen.
Is this okay? (y/N) y
ASCII armored output forced.
Revocation certificate created.

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

Il certificato di revoca è stato salvato nel file revocation_file.asc (asc per il formato ASCII):

sonya@debian:~/.gnupg$ ls
openpgp-revocs.d  private-keys-v1.d  pubring.kbx  revocation_file.asc  trustdb.gpg
sonya@debian:~/.gnupg$ cat revocation_file.asc
-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: This is a revocation certificate

iQHDBCABCgAtFiEEiIVjfDnnpieFi0wvnlcN6yLCeHEFAl8ASx4PHQJzdG9sZW4g
bGFwdG9wAAoJEJ5XDesiwnhxT9YMAKkjQiMpo9Uyiy9hyvukPPSrLcmtAGLk4pKS
pLZfzA5kxa+HPQwBglAEvfNRR6VMxqXUgUGYC/IAyQQM62oNAcY2PCPrxyJNgVF7
8l4mMZKvW++5ikjZwyg6WWV0+w6oroeo9qruJFjcu752p4T+9gsHVa2r+KRqcPQe
aZ65sAvsBJlcsUDZqfWUXg2kQp9mNPCdQuqvDaKRgNCHA1zbzNFzXWVd2X5RgFo5
nY+tUP8ZQA9DTQPBLPcggICmfLopMPZYB2bft5geb2mMi2oNpf9CNPdQkdccimNV
aRjqdUP9C89PwTafBQkQiONlsR/dWTFcqprG5KOWQPA7xjeMV8wretdEgsyTxqHp
v1iRzwjshiJCKBXXvz7wSmQrJ4OfiMDHeS4ipR0AYdO8QCzmOzmcFQKikGSHGMy1
z/YRlttd6NZIKjf1TD0nTrFnRvPdsZOlKYSArbfqNrHRBQkgirOD4JPI1tYKTffq
iOeZFx25K+fj2+0AJjvrbe4HDo5m+Q==
=umI8
-----END PGP PUBLIC KEY BLOCK-----

Per revocare effettivamente la tua chiave privata, hai ora bisogno di unire il certificato con la chiave, cosa che si fa importando il file del certificato di revoca nel tuo portachiavi:

sonya@debian:~/.gnupg$ gpg --import revocation_file.asc
gpg: key 9E570DEB22C27871: "sonya <sonya@debian>" revocation certificate imported
gpg: Total number processed: 1
gpg:    new key revocations: 1
gpg: marginals needed: 3  completes needed: 1  trust model: pgp
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: next trustdb check due at 2022-07-04

Elenca ora le tue chiavi e sarai informato della tua chiave revocata:

sonya@debian:~/.gnupg$ gpg --list-keys
/home/sonya/.gnupg/pubring.kbx
pub   rsa3072 2020-07-04 [SC] [revoked: 2020-07-04]
      8885637C39E7A627858B4C2F9E570DEB22C27871
uid           [ revoked] sonya <sonya@debian>

Infine, ma non meno importante, assicurati di rendere la chiave revocata disponibile a qualsiasi parte che abbia chiavi pubbliche associate a essa (inclusi i keyserver).

Usare GPG per Criptare, Cecriptare, Firmare e Verificare i File

Nella sezione precedente, carol ha inviato la sua chiave pubblica a ina. La useremo ora per discutere come GPG può criptare, decriptare, firmare e verificare i file.

Criptare e Decriptare i File

Per prima cosa, ina deve importare la chiave pubblica di carol (carol.pub.key) nel suo portachiavi in modo che possa iniziare a lavorare con essa:

ina@halof:~> gpg --import carol.pub.key
gpg: /home/ina/.gnupg/trustdb.gpg: trustdb created
gpg: key 19BBEFD16813034E: public key "carol <carol@debian>" imported
gpg: Total number processed: 1
gpg:               imported: 1
ina@halof:~> gpg --list-keys
/home/ina/.gnupg/pubring.kbx
----------------------------
pub   rsa3072 2020-07-03 [SC] [expires: 2022-07-03]
      D18FA0021F644CDAF57FD0F919BBEFD16813034E
uid           [ unknown] carol <carol@debian>
sub   rsa3072 2020-07-03 [E] [expires: 2022-07-03]

Poi creerai un file scrivendoci dentro del testo e poi lo cripterai usando gpg (poiché non hai firmato la chiave di carol, ti verrà chiesto esplicitamente se vuoi usare quella chiave):

ina@halof:~> echo "This is the message ..." > unencrypted-message
ina@halof:~> gpg --output encrypted-message --recipient carol --armor --encrypt unencrypted-message
gpg: 0227347CC92A5CB1: There is no assurance this key belongs to the named user
sub  rsa3072/0227347CC92A5CB1 2020-07-03 carol <carol@debian>
 Primary key fingerprint: D18F A002 1F64 4CDA F57F  D0F9 19BB EFD1 6813 034E
      Subkey fingerprint: 9D89 1BF9 39A4 C130 E44B  1135 0227 347C C92A 5CB1

NON è certo che la chiave appartenga alla persona nominata
nell'ID utente.  Se sapete veramente cosa state facendo,
potete rispondere alla prossima domanda con sì.

Usare comunque questa chiave? (y/N) y

Analizziamo il comando gpg:

--output encrypted-message

Specificazione del nome del file per la versione criptata del file originale (encrypted-message nell’esempio).

--recipient carol

Specificazione dello USER-ID del destinatario (carol nel nostro esempio). Se non viene fornito, GnuPG lo richiederà (a meno che non sia specificato --default-recipient).

--armor

Questa opzione produce un output ASCII "blindato", che può essere copiato in una email.

--encrypt unencrypted-message

Specificazione del nome del file originale da criptare.

Ora puoi inviare il messaggio criptato a Carol su Debian usando Scp:

ina@halof:~> scp encrypted-message carol@debian:/home/carol/
carol@debian's password:
encrypted-message                                                             100%  736     1.8MB/s   00:00

Se ora ti logghi come carol e provi a leggere il messaggio criptato, troverai che è effettivamente criptato e quindi illeggibile:

carol@debian:~$ cat encrypted-message
-----BEGIN PGP MESSAGE-----

hQGMAwInNHzJKlyxAQv/brJ8Ubs/xya35sbv6kdRKm1C7ONLxL3OueWA4mCs0Y/P
GBna6ZEUCrMEgl/rCyByj3Yq74kuiTmzxAIRUDdvHfj0TtrOWjVAqIn/fPSfMkjk
dTxKo1i55tLJ+sj17dGMZDcNBinBTP4U1atuN71A5w7vH+XpcesRcFQLKiSOmYTt
F7SN3/5x5J6io4ISn+b0KbJgiJNNx+Ne/ub4Uzk4NlK7tmBklyC1VRualtxcG7R9
1klBPYSld6fTdDwT1Y4MofpyILAiGMZvUR1RXauEKf7OIzwC5gWU+UQPSgeCdKQu
X7QL0ZIBS0Ug2XKrO1k93lmDjf8PWsRIml6n/hNelaOBA3HMP0b6Ozv1gFeEsFvC
IxhUYPb+rfuNFTMEB7xIO94AAmWB9N4qknMxdDqNE8WhA728Plw6y8L2ngsplY15
MR4lIFDpljA/CcVh4BXVe9j0TdFWDUkrFMfaIfcPQwKLXEYJp19XYIaaEazkOs5D
W4pENN0YOcX0KWyAYX6r0l8BF0rq/HMenQwqAVXMG3s8ATuUOeqjBbR1x1qCvRQP
CR/3V73aQwc2j5ioQmhWYpqxiro0yKX2Ar/E6rZyJtJYrq+CUk8O3JoBaudknNFj
pwuRwF1amwnSZ/MZ/9kMKQ==
=g1jw
-----END PGP MESSAGE-----

Tuttavia, poiché sei in possesso della chiave privata, puoi facilmente decifrare il messaggio passando a gpg l’opzione --decrypt seguita dal percorso del file cifrato (sarà richiesta la passphrase della chiave privata):

carol@debian:~$ gpg --decrypt encrypted-message
gpg: encrypted with 3072-bit RSA key, ID 0227347CC92A5CB1, created 2020-07-03
      "carol <carol@debian>"
This is the message ...

Puoi anche specificare l’opzione --output per salvare il messaggio in un nuovo file non criptato:

carol@debian:~$ gpg --output unencrypted-message --decrypt encrypted-message
gpg: encrypted with 3072-bit RSA key, ID 0227347CC92A5CB1, created 2020-07-03
      "carol <carol@debian>"
carol@debian:~$ cat unencrypted-message
This is the message ...

Firmare e Verificare i File

Oltre a criptare, GPG può anche essere usato per firmare i file. L’opzione --sign è rilevante in questo caso. Iniziamo creando un nuovo messaggio (message) e firmiamolo con l’opzione --sign (sarà richiesta la passphrase della tua chiave privata):

carol@debian:~$ echo "This is the message to sign ..." > message
carol@debian:~$ gpg --output message.sig --sign message
(...)

Spiegazione del comando gpg:

--output message

nome del file della versione firmata (message.sig nel nostro esempio).

--sign message

Percorso del file originale.

Note

Usando --sign il documento viene compresso e poi firmato. L’output è in formato binario.

Poi trasferiremo il file a ina su halof usando scp message.sig ina@halof:/home/ina . Tornati come ina su halof, puoi ora verificarlo usando l’opzione --verify:

ina@halof:~> gpg --verify message.sig
gpg: Signature made Sat 04 jul 2020 14:34:41 CEST
gpg:                using RSA key D18FA0021F644CDAF57FD0F919BBEFD16813034E
gpg: Good signature from "carol <carol@debian>" [unknown]
(...)

Se vuoi anche leggere il file, devi decriptarlo in un nuovo file (message nel nostro caso) usando l’opzione --output:

ina@halof:~> gpg --output message --decrypt message.sig
gpg: Signature made Sat 04 jul 2020 14:34:41 CEST
gpg:                using RSA key D18FA0021F644CDAF57FD0F919BBEFD16813034E
gpg: Good signature from "carol <carol@debian>" [unknown]
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: D18F A002 1F64 4CDA F57F  D0F9 19BB EFD1 6813 034E
ina@halof:~> cat message
This is the message to sign ...
GPG-Agent

Completeremo questa lezione trattando brevemente gpg-agent. gpg-agent è il demone che gestisce le chiavi private per GPG (è avviato su richiesta da gpg). Per vedere un riassunto delle opzioni più utili, esegui gpg-agent --help o gpg-agent -h:

carol@debian:~$ gpg-agent --help
gpg-agent (GnuPG) 2.2.4
libgcrypt 1.8.1
Copyright (C) 2017 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Syntax: gpg-agent [options] [command [args]]
Secret key management for GnuPG

Options:

     --daemon                        run in daemon mode (background)
     --server                        run in server mode (foreground)
     --supervised                    run in supervised mode
 -v, --verbose                       verbose
 -q, --quiet                         be somewhat more quiet
 -s, --sh                            sh-style command output
 -c, --csh                           csh-style command output
(...)
Note

Per maggiori informazioni, consultare la pagina man di gpg-agent.

Esercizi Guidati

  1. Completa la tabella fornendo il nome corretto del file:

    Descrizione Nome del file

    Database di fiducia

    Directory per i certificati di revoca

    Directory per le chiavi private

    Portachiavi chiavi pubbliche

  2. Rispondi alle seguenti domande:

    • Che tipo di crittografia è usata da GnuPG?

    • Quali sono i due componenti principali della crittografia a chiave pubblica?

    • Qual è il KEY-ID dell’impronta della chiave pubblica 07A6 5898 2D3A F3DD 43E3 DA95 1F3F 3147 FA7F 54C7?

    • Quale metodo si usa per distribuire le chiavi pubbliche a livello globale?

  3. Metti i seguenti passi nel giusto ordine per quanto riguarda la revoca della chiave privata:

    • Rendi la chiave revocata disponibile ai tuoi corrispondenti.

    • Crea un certificato di revoca.

    • Importa il certificato di revoca nel tuo portachiavi.

      L’ordine corretto è:

      Passo 1:

      Passo 2:

      Passo 3:

  4. Per quanto riguarda la crittografia dei file, cosa implica l’opzione --armor nel comando gpg --output encrypted-message --recipient carol --armor --encrypt unencrypted-message?

Esercizi Esplorativi

  1. La maggior parte delle opzioni gpg hanno sia una versione lunga si una corta. Completa la tabella con la corrispondente versione breve:

    Versione lunga Versione breve

    --armor

    --output

    --recipient

    --decrypt

    --encrypt

    --sign

  2. Rispondi alle seguenti domande riguardanti l’esportazione di una chiave:

    • Quale comando useresti per esportare tutte le tue chiavi pubbliche in un file chiamato all.key?

    • Quale comando useresti per esportare tutte le tue chiavi private in un file chiamato all_private.key?

  3. Quale opzione gpg permette di eseguire la maggior parte dei compiti relativi alla gestione delle chiavi presentandovi un menu?

  4. Quale opzione gpg ti permette di fare una firma in chiaro?

Sommario

Questa lezione ha trattato il GNU Privacy Guard, una scelta eccellente per criptare/decriptare e firmare/verificare digitalmente i file. Hai imparato:

  • come generare una coppia di chiavi.

  • come elencare le chiavi nel portachiavi.

  • il contenuto della directory ~/.gnupg.

  • cosa sono USER-ID e KEY-ID.

  • come distribuire le chiavi pubbliche ai vostri corrispondenti.

  • come distribuire globalmente le chiavi pubbliche attraverso i keyserver.

  • come revocare le chiavi private.

  • come criptare e decriptare i file.

  • come firmare e verificare i file.

  • le basi del GPG-Agent.

I seguenti comandi sono stati discussi in questa lezione:

gpg

Lo strumento di crittografia e firma OpenPGP.

Risposte agli Esercizi Guidati

  1. Completa la tabella fornendo il nome corretto del file:

    Descrizione Nome del file

    Database di fiducia

    trustdb.gpg

    Directory per i certificati di revoca

    opengp-revocs.d

    Directory per le chiavi private

    private-keys-v1.d

    Portachiavi chiavi pubbliche

    pubring.kbx

  2. Rispondi alle seguenti domande:

    • Che tipo di crittografia è usata da GnuPG?

      Crittografia a chiave pubblica o crittografia asimmetrica.

    • Quali sono i due componenti principali della crittografia a chiave pubblica?

      Le chiavi pubbliche e private.

    • Qual è il KEY-ID dell’impronta della chiave pubblica 07A6 5898 2D3A F3DD 43E3 DA95 1F3F 3147 FA7F 54C7?

      FA7F 54C7

    • Quale metodo si usa per distribuire le chiavi pubbliche a livello globale?

      I key server.

  3. Metti i seguenti passi nel giusto ordine per quanto riguarda la revoca della chiave privata:

    • Rendi la chiave revocata disponibile ai tuoi corrispondenti.

    • Crea un certificato di revoca.

    • Importa il certificato di revoca nel tuo portachiavi.

      L’ordine corretto è:

      Passo 1:

      Crea un certificato di revoca.

      Passo 2:

      Importa il certificato di revoca nel tuo portachiavi.

      Passo 3:

      Rendi la chiave revocata disponibile ai tuoi corrispondenti.

  4. Per quanto riguarda la crittografia dei file, cosa implica l’opzione --armor nel comando gpg --output encrypted-message --recipient carol --armor --encrypt unencrypted-message?

    Produce un output ASCII "blindato ", che permette di copiare il file crittografato risultante in una e-mail.

Risposte agli Esercizi Esplorativi

  1. La maggior parte delle opzioni gpg hanno sia una versione lunga sia una corta. Completa la tabella con la corrispondente versione breve:

    Versione lunga Versione breve

    --armor

    -a

    --output

    -o

    --recipient

    -r

    --decrypt

    -d

    --encrypt

    -e

    --sign

    -s

  2. Rispondi alle seguenti domande riguardanti l’esportazione di una chiave:

    • Quale comando useresti per esportare tutte le tue chiavi pubbliche in un file chiamato all.key?

      gpg --export --output all.key o gpg --export -o all.key

    • Quale comando useresti per esportare tutte le tue chiavi private in un file chiamato all_private.key?

      gpg --export-secret-keys --output all_private.key o gpg --export-secret-keys -o all_private.key (--export-secret-keys può essere sostituito da --export-secret-subkeys con un risultato leggermente diverso — controlla man pgp per maggiori informazioni).

  3. Quale opzione gpg permette di eseguire la maggior parte dei compiti relativi alla gestione delle chiavi presentandovi un menu?

    --edit-key

  4. Quale opzione gpg ti permette di fare una firma in chiaro?

    --clearsign

Linux Professional Institute Inc. Tutti i diritti riservati. Visita il sito Learning Materials: https://learning.lpi.org
Quest'opera è sotto la licenza 'Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License'.