{"id":100,"date":"2026-06-13T16:55:58","date_gmt":"2026-06-13T16:55:58","guid":{"rendered":"https:\/\/shattered.io\/it\/2026\/06\/13\/gpg-cifrare-firmare-file\/"},"modified":"2026-06-13T16:57:45","modified_gmt":"2026-06-13T16:57:45","slug":"gpg-cifrare-firmare-file","status":"publish","type":"post","link":"https:\/\/shattered.io\/it\/2026\/06\/13\/gpg-cifrare-firmare-file\/","title":{"rendered":"GPG: Cifrare e Firmare File in 12 Step [2026]"},"content":{"rendered":"\n

Cifrare un file con una password che chiunque pu\u00f2 indovinare non protegge niente. GPG<\/strong> (GNU Privacy Guard, o GnuPG) risolve il problema alla radice: usa crittografia a chiave pubblica per cifrare dati che solo il destinatario pu\u00f2 leggere e per firmare messaggi che chiunque pu\u00f2 verificare. \u00c8 lo standard de facto della crittografia OpenPGP da oltre vent’anni, \u00e8 gratuito, open source e gira su Linux, macOS e Windows.<\/p>\n\n\n\n

Questa guida pratica copre l’intero ciclo di vita con GPG<\/strong>: installazione, generazione delle chiavi moderne su curva ellittica Ed25519, certificato di revoca, pubblicazione su keyserver, cifratura asimmetrica e simmetrica, firme digitali, sottochiavi su YubiKey e automazione. Tutti i comandi sono testati su GnuPG 2.5.x, la serie dichiarata stabile nel dicembre 2025. Alla fine avrai un setup completo e funzionante, non una raccolta di comandi isolati.<\/p>\n\n\n\n

Aggiornata al 13 giugno 2026, la guida include le novit\u00e0 del 2025 e 2026: il nuovo standard OpenPGP<\/strong> RFC 9580, la separazione con LibrePGP, lo stato della crittografia post-quantistica e la deprecazione definitiva dei vecchi keyserver SKS a favore di Web Key Directory.<\/p>\n\n\n\n

Che cos’\u00e8 GPG e perch\u00e9 usarlo nel 2026<\/h2>\n\n\n\n

GPG<\/strong> \u00e8 l’implementazione libera e completa dello standard OpenPGP. Il progetto GnuPG lo descrive cos\u00ec sul sito ufficiale: un software che permette di cifrare e firmare dati e comunicazioni usando un sistema di chiavi versatile. Il nome tecnico \u00e8 GnuPG, ma sulla riga di comando il programma si chiama gpg<\/code>, e nell’uso quotidiano i due termini sono intercambiabili.<\/p>\n\n\n\n

Il principio \u00e8 la crittografia asimmetrica. Ogni utente possiede due chiavi matematicamente collegate: una chiave pubblica<\/strong>, che distribuisci liberamente, e una chiave privata<\/strong>, che custodisci e non condividi mai. Chi vuole inviarti un file lo cifra con la tua chiave pubblica, e solo la tua chiave privata pu\u00f2 decifrarlo. Per le firme il meccanismo si inverte: firmi con la chiave privata e chiunque verifica con la tua chiave pubblica. Questo schema, basato sulle stesse fondamenta delle firme digitali<\/a>, garantisce riservatezza, autenticit\u00e0 e integrit\u00e0 in un solo strumento.<\/p>\n\n\n\n

Nel 2026 GPG resta rilevante per ragioni concrete. La cifratura delle email tramite OpenPGP non dipende da nessun fornitore: funziona tra ProtonMail, Thunderbird, Outlook e qualsiasi client compatibile. La firma dei pacchetti software e dei commit Git si appoggia quasi ovunque a GPG. Le distribuzioni Linux verificano gli aggiornamenti con firme OpenPGP. E per archiviare file sensibili su un disco o nel cloud, una cifratura simmetrica con gpg -c<\/code> \u00e8 pi\u00f9 semplice e portabile di soluzioni proprietarie.<\/p>\n\n\n\n

La differenza rispetto ad altri strumenti sta nel modello di fiducia decentralizzato. Non esiste un’autorit\u00e0 centrale che certifica le chiavi, come accade invece per i certificati TLS gestiti da OpenSSL. Sei tu a decidere di chi fidarti, verificando le impronte (fingerprint) delle chiavi. Se ti serve un confronto con la cifratura a livello di trasporto, la nostra guida su HTTPS e TLS<\/a> spiega il modello opposto, quello delle autorit\u00e0 di certificazione.<\/p>\n\n\n\n

GPG non \u00e8 perfetto. La gestione delle chiavi richiede disciplina, l’interfaccia a riga di comando intimidisce i principianti e la cifratura delle email ha limiti noti, come i metadati esposti nell’oggetto del messaggio. Ma per cifrare file, firmare rilasci e proteggere segreti, resta lo strumento pi\u00f9 solido e diffuso. Questa guida ti porta da zero a un setup professionale.<\/p>\n\n\n\n

Prerequisiti e versioni aggiornate al 2026<\/h2>\n\n\n\n

Prima di iniziare ti servono pochi elementi: un terminale, i permessi per installare software e cinque minuti. La serie stabile attuale \u00e8 GnuPG 2.5.x. Il progetto ha dichiarato la 2.5 come ramo stabile a dicembre 2025, mentre la vecchia 2.4 \u00e8 passata in stato “oldstable”. Verifica sempre la versione che hai installato con gpg --version<\/code>, perch\u00e9 i pacchetti delle distribuzioni spesso restano indietro rispetto agli ultimi rilasci ufficiali.<\/p>\n\n\n\n

La tabella seguente elenca i componenti principali dello stack GnuPG con le versioni pubblicate sulla pagina di download ufficiale a giugno 2026. GPG non \u00e8 un binario monolitico: si appoggia a una serie di librerie (Libgcrypt per la crittografia, pinentry per l’inserimento delle passphrase, GPGME come API ad alto livello) che vengono aggiornate separatamente.<\/p>\n\n\n\n

\n
Componente<\/th>Versione<\/th>Data di rilascio<\/th>Funzione<\/th><\/tr><\/thead>
GnuPG (stable)<\/td>2.5.20<\/td>13 maggio 2026<\/td>Programma principale gpg<\/code><\/td><\/tr>\n
GnuPG (oldstable)<\/td>2.4.9<\/td>30 dicembre 2025<\/td>Ramo legacy 2.4.x<\/td><\/tr>\n
Libgcrypt<\/td>1.12.2<\/td>15 aprile 2026<\/td>Libreria crittografica di base<\/td><\/tr>\n
pinentry<\/td>1.3.2<\/td>28 luglio 2025<\/td>Inserimento passphrase e PIN<\/td><\/tr>\n
GPGME<\/td>2.1.0<\/td>18 maggio 2026<\/td>API per applicazioni e GUI<\/td><\/tr>\n
Libgpg-error<\/td>1.61<\/td>7 maggio 2026<\/td>Gestione errori comune<\/td><\/tr>\n
Libksba<\/td>1.8.0<\/td>13 maggio 2026<\/td>Supporto X.509 e CMS<\/td><\/tr>\n
GPA<\/td>0.11.1<\/td>12 febbraio 2026<\/td>Interfaccia grafica<\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n\n\n

Per gli utenti Windows il pacchetto di riferimento \u00e8 Gpg4win<\/strong>, che include GnuPG, il gestore di certificati Kleopatra e l’integrazione con Outlook tramite GpgOL. Su macOS la scelta comune \u00e8 GPG Suite<\/strong>, che aggiunge integrazione con Mail e portachiavi. Su Linux GPG \u00e8 quasi sempre gi\u00e0 presente o installabile dai repository ufficiali. Scarica sempre l’ultima versione disponibile dai siti ufficiali, perch\u00e9 i numeri cambiano di frequente.<\/p>\n\n\n\n

Un consiglio prima di partire: lavora su una macchina di cui ti fidi. La sicurezza di GPG dipende dalla protezione della chiave privata. Se il computer \u00e8 compromesso, nessuna passphrase ti salva. Per dati ad altissimo valore, valuta la generazione delle chiavi su un sistema offline o su un sistema operativo orientato alla privacy come Tails.<\/p>\n\n\n\n

Step 1: Installare GnuPG su Linux, macOS e Windows<\/h2>\n\n\n\n

L’installazione cambia in base al sistema operativo, ma in tutti i casi richiede meno di un minuto. Parti dal tuo gestore di pacchetti e verifica subito la versione.<\/p>\n\n\n\n

Su Debian, Ubuntu<\/strong> e derivate installa il pacchetto completo, che include gli strumenti per le smartcard e i moduli di rete per i keyserver:<\/p>\n\n\n\n

# Debian \/ Ubuntu\nsudo apt update\nsudo apt install gnupg gnupg-agent scdaemon\n\n# Fedora \/ RHEL\nsudo dnf install gnupg2\n\n# Arch Linux\nsudo pacman -S gnupg\n\n# macOS con Homebrew\nbrew install gnupg pinentry-mac<\/code><\/pre>\n\n\n\n
Su Windows<\/strong> scarica l’installer di Gpg4win dal sito ufficiale ed esegui il setup grafico. Il pacchetto registra il comando gpg<\/code> nel PATH, quindi potrai usarlo sia da PowerShell sia dall’interfaccia Kleopatra. Su macOS<\/strong>, se preferisci un’esperienza integrata con interfaccia grafica, installa GPG Suite invece di Homebrew.<\/p>\n\n\n\n
Subito dopo l’installazione verifica che tutto sia a posto:<\/p>\n\n\n\n
gpg --version<\/code><\/pre>\n\n\n\n
L’output mostra la versione del programma e gli algoritmi supportati:<\/p>\n\n\n\n
gpg (GnuPG) 2.5.20\nlibgcrypt 1.12.2\nCopyright (C) 2026 g10 Code GmbH\n...\nAlgoritmi supportati:\nChiave pubblica: RSA, ELG, DSA, ECDH, ECDSA, EDDSA\nCifratura: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH\nHash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224\nCompressione: Non compresso, ZIP, ZLIB, BZIP2<\/code><\/pre>\n\n\n\n
Controlla due cose nell’output. La prima: la riga EDDSA<\/code> e ECDH<\/code> negli algoritmi a chiave pubblica conferma il supporto alle curve moderne come Ed25519 e Curve25519, quelle che useremo. La seconda: AES256<\/code> tra le cifrature simmetriche. Se vedi una versione 2.2.x o precedente, il sistema operativo \u00e8 datato e alcune funzionalit\u00e0 potrebbero mancare. In quel caso valuta l’aggiornamento del sistema o l’installazione dai sorgenti.<\/p>\n\n\n\n
Una nota per chi usa Windows: il supporto ufficiale di alcuni strumenti correlati alla riga di comando \u00e8 stato interrotto su quella piattaforma, ma GnuPG su Windows tramite Gpg4win resta pienamente mantenuto. Non confondere lo stato dei diversi progetti.<\/p>\n\n\n\n
Step 2: Configurare gpg-agent e pinentry<\/h2>\n\n\n\n
Prima di generare chiavi vale la pena configurare l’ambiente. gpg-agent<\/strong> \u00e8 il demone che gestisce le chiavi private in memoria e ti evita di reinserire la passphrase a ogni operazione. Il programma pinentry<\/strong> \u00e8 quello che mostra la finestra (grafica o testuale) in cui digiti la passphrase. Quando questi due componenti non collaborano nascono molti errori comuni.<\/p>\n\n\n\n
Crea la directory di configurazione con i permessi corretti. La cartella ~\/.gnupg<\/code> deve essere accessibile solo dal tuo utente, altrimenti GPG si rifiuta di funzionare per ragioni di sicurezza:<\/p>\n\n\n\n
mkdir -p ~\/.gnupg\nchmod 700 ~\/.gnupg<\/code><\/pre>\n\n\n\n
Configura gpg-agent creando il file ~\/.gnupg\/gpg-agent.conf<\/code>. Le righe seguenti impostano una cache della passphrase di due ore e specificano il programma pinentry. Su macOS usa pinentry-mac<\/code>, su Linux con interfaccia grafica pinentry-gnome3<\/code> o pinentry-qt<\/code>, in ambienti solo testo pinentry-curses<\/code>:<\/p>\n\n\n\n
# ~\/.gnupg\/gpg-agent.conf\ndefault-cache-ttl 7200\nmax-cache-ttl 28800\npinentry-program \/usr\/bin\/pinentry-curses\n\n# Su macOS:\n# pinentry-program \/opt\/homebrew\/bin\/pinentry-mac<\/code><\/pre>\n\n\n\n
Imposta poi alcuni valori predefiniti per le preferenze degli algoritmi nel file ~\/.gnupg\/gpg.conf<\/code>. Queste righe dicono a GPG di preferire algoritmi forti e di mostrare le impronte complete a 40 caratteri, riducendo il rischio di confondere chiavi diverse:<\/p>\n\n\n\n
# ~\/.gnupg\/gpg.conf\npersonal-cipher-preferences AES256 AES192 AES\npersonal-digest-preferences SHA512 SHA384 SHA256\ncert-digest-algo SHA512\ndefault-preference-list SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed\nkeyid-format 0xlong\nwith-fingerprint\nno-emit-version\nno-comments<\/code><\/pre>\n\n\n\n
Dopo aver modificato la configurazione, riavvia l’agent perch\u00e9 legga i nuovi valori:<\/p>\n\n\n\n
gpgconf --kill gpg-agent\ngpg-connect-agent \/bye<\/code><\/pre>\n\n\n\n
Questa configurazione iniziale ti risparmia ore di debugging. La cache della passphrase rende l’uso quotidiano fluido, le preferenze sugli algoritmi garantiscono che firme e cifrature usino SHA-512 e AES-256 invece di default pi\u00f9 deboli, e il formato esteso dei key ID previene gli attacchi basati su collisioni di identificatori brevi. Se vuoi capire meglio perch\u00e9 SHA-512 conta, leggi la nostra spiegazione su come funzionano le funzioni hash crittografiche<\/a>.<\/p>\n\n\n\n
Step 3: Generare una coppia di chiavi Ed25519<\/h2>\n\n\n\n
Arriviamo al cuore della guida. Genereremo una coppia di chiavi moderna basata sulla curva ellittica Ed25519 per la firma e Curve25519 per la cifratura. Rispetto a RSA, le curve ellittiche offrono la stessa sicurezza con chiavi molto pi\u00f9 piccole e operazioni pi\u00f9 rapide. Una chiave Ed25519 da 256 bit fornisce una robustezza paragonabile a una RSA da circa 3072 bit, ma \u00e8 enormemente pi\u00f9 veloce.<\/p>\n\n\n\n
Il modo pi\u00f9 controllato per generare le chiavi \u00e8 la modalit\u00e0 interattiva avanzata, che ti permette di scegliere l’algoritmo:<\/p>\n\n\n\n
gpg --full-generate-key --expert<\/code><\/pre>\n\n\n\n
GPG ti chieder\u00e0 il tipo di chiave. Scegli l’opzione per ECC (curve ellittiche), poi seleziona Curve 25519. Imposta una scadenza ragionevole, ad esempio due anni, e inserisci nome, email e un commento opzionale. Al termine GPG ti chieder\u00e0 una passphrase robusta: questa \u00e8 l’ultima linea di difesa se qualcuno copia il tuo file di chiave privata.<\/p>\n\n\n\n
Per chi preferisce un comando rapido e non interattivo, la modalit\u00e0 veloce produce lo stesso risultato in una riga sola. Il primo comando crea la chiave primaria di firma, il secondo aggiunge una sottochiave di cifratura:<\/p>\n\n\n\n
# Chiave primaria Ed25519 valida 2 anni\ngpg --quick-generate-key \"Mario Rossi <mario@example.it>\" ed25519 sign 2y\n\n# Aggiungi una sottochiave di cifratura Curve25519\ngpg --quick-add-key TUO_FINGERPRINT cv25519 encrypt 2y<\/code><\/pre>\n\n\n\n
Sostituisci TUO_FINGERPRINT<\/code> con l’impronta completa della chiave appena creata, che recuperi con gpg --list-keys --with-colons<\/code>. Una volta generate le chiavi, verifica il risultato:<\/p>\n\n\n\n
gpg --list-secret-keys --keyid-format=long<\/code><\/pre>\n\n\n\n
L’output mostra la chiave primaria (sec), la sottochiave (ssb), l’identit\u00e0 utente (uid) e l’impronta a 40 caratteri esadecimali:<\/p>\n\n\n\n
sec   ed25519\/0x4F2A9C1B8E7D5A30 2026-06-13 [SC] [scade: 2028-06-12]\n      A1B2C3D4E5F60718293A4B5C6D7E8F904F2A9C1B\nuid                 [  assoluta ] Mario Rossi <mario@example.it>\nssb   cv25519\/0x9D3E1F7A2C8B6045 2026-06-13 [E] [scade: 2028-06-12]<\/code><\/pre>\n\n\n\n
I codici tra parentesi quadre indicano le capacit\u00e0: S<\/code> per firma, C<\/code> per certificazione, E<\/code> per cifratura. La chiave primaria firma e certifica, la sottochiave cifra. L’impronta completa (la riga di 40 caratteri) \u00e8 il dato da condividere e verificare di persona: il key ID breve pu\u00f2 essere falsificato, l’impronta completa no.<\/p>\n\n\n\n
Se hai bisogno della massima compatibilit\u00e0 con sistemi datati, puoi ancora generare chiavi RSA 4096. La tabella seguente confronta le opzioni cos\u00ec scegli con cognizione di causa.<\/p>\n\n\n\n
\n
Tipo di chiave<\/th>Dimensione<\/th>Velocit\u00e0<\/th>Compatibilit\u00e0<\/th>Quando usarla<\/th><\/tr><\/thead>
Ed25519 \/ Curve25519<\/td>256 bit<\/td>Molto alta<\/td>Buona (GPG 2.1+)<\/td>Scelta predefinita nel 2026<\/td><\/tr>\n
RSA 4096<\/td>4096 bit<\/td>Bassa<\/td>Massima<\/td>Sistemi legacy o hardware datato<\/td><\/tr>\n
RSA 3072<\/td>3072 bit<\/td>Media<\/td>Massima<\/td>Compromesso compatibilit\u00e0\/prestazioni<\/td><\/tr>\n
NIST P-256<\/td>256 bit<\/td>Alta<\/td>Buona<\/td>Requisiti di conformit\u00e0 FIPS<\/td><\/tr>\n
RSA 2048<\/td>2048 bit<\/td>Media<\/td>Massima<\/td>Sconsigliata per nuove chiavi<\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n\n\n
Step 4: Creare il certificato di revoca<\/h2>\n\n\n\n
Questo passaggio sembra noioso e viene saltato di continuo. \u00c8 l’errore pi\u00f9 costoso che puoi commettere con GPG. Il certificato di revoca<\/strong> \u00e8 un file che annulla pubblicamente la tua chiave. Ti serve quando perdi la chiave privata, quando dimentichi la passphrase o quando la chiave viene compromessa. Senza di esso, una chiave compromessa resta valida agli occhi del mondo finch\u00e9 non scade, e nessuno pu\u00f2 fermarla.<\/p>\n\n\n\n
Il punto cruciale \u00e8 generare il certificato di revoca subito<\/strong>, quando hai ancora accesso alla chiave privata e ricordi la passphrase. Se aspetti il momento in cui ti serve davvero, sar\u00e0 troppo tardi. Genera il certificato cos\u00ec:<\/p>\n\n\n\n
gpg --output ~\/revoca-mario.asc --gen-revoke 0x4F2A9C1B8E7D5A30<\/code><\/pre>\n\n\n\n
GPG ti chieder\u00e0 il motivo della revoca. Per un certificato preventivo scegli “nessun motivo specificato” o “la chiave \u00e8 stata compromessa”. Inserisci la passphrase e otterrai un file ASCII. Il contenuto assomiglia a questo:<\/p>\n\n\n\n
-----BEGIN PGP PUBLIC KEY BLOCK-----\nComment: Questo e' un certificato di revoca\n\niHgEIBYIACAWIQShssPU5fYHGCk6S1xtfo+QTyqcGwUCZ...\n...\n=aB3x\n-----END PGP PUBLIC KEY BLOCK-----<\/code><\/pre>\n\n\n\n
Ora la parte delicata: dove conservarlo. Questo file ha lo stesso potere distruttivo di un comando di cancellazione. Chiunque lo possieda pu\u00f2 revocare la tua chiave. Conservalo su una chiavetta USB cifrata, stampato in cassaforte o in un password manager sicuro. Non lasciarlo nella cartella ~\/.gnupg<\/code> accanto alla chiave: se perdi quella directory, perdi anche il certificato.<\/p>\n\n\n\n
Se un giorno dovrai usarlo, lo importi e lo pubblichi sui keyserver con due comandi:<\/p>\n\n\n\n
gpg --import ~\/revoca-mario.asc\ngpg --keyserver hkps:\/\/keys.openpgp.org --send-keys 0x4F2A9C1B8E7D5A30<\/code><\/pre>\n\n\n\n
Da quel momento chiunque scarichi la tua chiave vedr\u00e0 che \u00e8 revocata e smetter\u00e0 di usarla per cifrare nuovi messaggi. La revoca \u00e8 permanente e non si annulla, quindi usala solo quando serve davvero.<\/p>\n\n\n\n
Step 5: Esportare e pubblicare la chiave pubblica<\/h2>\n\n\n\n
La chiave pubblica esiste per essere distribuita. Pi\u00f9 persone la hanno, pi\u00f9 persone possono inviarti messaggi cifrati e verificare le tue firme. Esportala in formato ASCII (detto “armatura”) con l’opzione --armor<\/code>, che produce testo leggibile invece di dati binari, comodo da incollare in email e pagine web:<\/p>\n\n\n\n
# Esporta la chiave pubblica in formato testo\ngpg --armor --export 0x4F2A9C1B8E7D5A30 > mario-pubblica.asc\n\n# Esporta la chiave privata per il backup (custodiscila!)\ngpg --armor --export-secret-keys 0x4F2A9C1B8E7D5A30 > mario-privata.asc<\/code><\/pre>\n\n\n\n
Il file della chiave pubblica inizia con -----BEGIN PGP PUBLIC KEY BLOCK-----<\/code> e puoi condividerlo senza timori. Il file della chiave privata, invece, va trattato come il segreto pi\u00f9 prezioso che hai: cifralo, mettilo su supporto offline e non caricarlo mai online.<\/p>\n\n\n\n
Keyserver moderni e WKD<\/h3>\n\n\n\n
Per anni i keyserver SKS hanno permesso di cercare chiavi per email. Quella rete \u00e8 ormai deprecata: soffriva di attacchi di “avvelenamento” delle chiavi e di problemi di manutenzione, e oggi \u00e8 praticamente abbandonata. Il keyserver di riferimento nel 2026 \u00e8 keys.openpgp.org<\/strong>, che verifica le email prima di pubblicare gli indirizzi e non accetta firme di terzi non richieste. Pubblica la tua chiave cos\u00ec:<\/p>\n\n\n\n
gpg --keyserver hkps:\/\/keys.openpgp.org --send-keys 0x4F2A9C1B8E7D5A30<\/code><\/pre>\n\n\n\n
L’alternativa pi\u00f9 robusta \u00e8 Web Key Directory<\/strong> (WKD), un meccanismo che pubblica la chiave su un percorso standard del tuo dominio web. Quando qualcuno cifra un messaggio per mario@example.it<\/code>, il suo client GPG scarica automaticamente la chiave da example.it<\/code> senza bisogno di keyserver. \u00c8 il modo pi\u00f9 affidabile per distribuire chiavi a chi possiede un dominio proprio, ed \u00e8 il metodo che la nostra guida su Proton Mail e Tuta<\/a> menziona per l’interoperabilit\u00e0 tra provider di posta cifrata.<\/p>\n\n\n\n
Step 6: Importare e verificare le chiavi altrui<\/h2>\n\n\n\n
Per cifrare un file destinato a qualcuno, ti serve la sua chiave pubblica. Importarla \u00e8 banale; verificarla \u00e8 il passaggio che la gente salta e che invece determina se GPG ti protegge davvero. Importa una chiave ricevuta come file:<\/p>\n\n\n\n
gpg --import chiave-di-anna.asc<\/code><\/pre>\n\n\n\n
Oppure scaricala da un keyserver cercando per email o impronta:<\/p>\n\n\n\n
gpg --keyserver hkps:\/\/keys.openpgp.org --search-keys anna@example.it\n# oppure cercala tramite WKD del suo dominio\ngpg --locate-keys anna@example.it<\/code><\/pre>\n\n\n\n
Ora il punto critico. Importare una chiave non significa fidarsi di essa. Un attaccante potrebbe pubblicare una chiave falsa con il nome e l’email di Anna. Per verificare che la chiave sia autentica devi confrontare la sua impronta con quella che Anna ti comunica attraverso un canale separato e affidabile: di persona, per telefono riconoscendo la voce, o via un messaggio firmato su un canale gi\u00e0 verificato. Mostra l’impronta cos\u00ec:<\/p>\n\n\n\n
gpg --fingerprint anna@example.it<\/code><\/pre>\n\n\n\n
Quando le 40 cifre coincidono, e solo allora, certifica la chiave come affidabile firmandola localmente. Questo dice a GPG che ti fidi di quella chiave per quell’identit\u00e0:<\/p>\n\n\n\n
gpg --sign-key anna@example.it<\/code><\/pre>\n\n\n\n
Questo \u00e8 il modello di fiducia decentralizzato di OpenPGP, storicamente chiamato “rete di fiducia” (web of trust). A differenza dei certificati TLS verificati da un’autorit\u00e0 centrale, qui sei tu a decidere di chi fidarti. Il confronto delle impronte \u00e8 l’unico passaggio che separa una comunicazione sicura da una vulnerabile a un attacco “man in the middle”. Non saltarlo mai per le chiavi che contano.<\/p>\n\n\n\n
Step 7: Cifrare un file con la chiave pubblica<\/h2>\n\n\n\n
Con le chiavi pronte, cifrare \u00e8 semplice. La cifratura asimmetrica usa la chiave pubblica del destinatario, cos\u00ec solo lui potr\u00e0 decifrare con la sua chiave privata. Cifra un file per Anna:<\/p>\n\n\n\n
# Cifratura binaria (produce contratto.pdf.gpg)\ngpg --encrypt --recipient anna@example.it contratto.pdf\n\n# Cifratura in formato testo ASCII (produce contratto.pdf.asc)\ngpg --encrypt --armor --recipient anna@example.it contratto.pdf<\/code><\/pre>\n\n\n\n
Spesso vuoi cifrare un file in modo che tu stesso<\/strong> possa rileggerlo, oltre al destinatario. Per impostazione predefinita un file cifrato solo per Anna non \u00e8 leggibile nemmeno da te. Aggiungi te stesso tra i destinatari:<\/p>\n\n\n\n
gpg --encrypt --armor \\\n    --recipient anna@example.it \\\n    --recipient mario@example.it \\\n    contratto.pdf<\/code><\/pre>\n\n\n\n
La combinazione pi\u00f9 usata nella pratica \u00e8 cifrare e<\/strong> firmare in un solo comando. Cos\u00ec Anna riceve un file riservato che pu\u00f2 anche verificare provenire davvero da te:<\/p>\n\n\n\n
gpg --encrypt --sign --armor --recipient anna@example.it contratto.pdf<\/code><\/pre>\n\n\n\n
Per decifrare un file ricevuto, Anna esegue semplicemente:<\/p>\n\n\n\n
gpg --decrypt contratto.pdf.asc > contratto.pdf<\/code><\/pre>\n\n\n\n
GPG le chieder\u00e0 la passphrase, decifrer\u00e0 il contenuto e, se il file era anche firmato, mostrer\u00e0 l’esito della verifica della firma. Un output di successo riporta qualcosa del tipo: gpg: Firma valida da \"Mario Rossi\"<\/code>. Se la firma non \u00e8 valida, GPG lo segnala in modo evidente e dovresti trattare il file come sospetto.<\/p>\n\n\n\n
Step 8: Cifratura simmetrica con passphrase<\/h2>\n\n\n\n
Non sempre serve la crittografia a chiave pubblica. Per proteggere un file che vuoi solo archiviare, o da condividere con qualcuno che non usa GPG, la cifratura simmetrica<\/strong> \u00e8 pi\u00f9 pratica. Usa una sola passphrase, senza chiavi pubbliche, e chiunque conosca la passphrase pu\u00f2 decifrare. Il comando \u00e8 breve:<\/p>\n\n\n\n
gpg --symmetric --cipher-algo AES256 backup.tar<\/code><\/pre>\n\n\n\n
L’opzione --cipher-algo AES256<\/code> forza l’uso di AES a 256 bit, l’algoritmo standard per la cifratura robusta, lo stesso analizzato nella nostra guida su come cifrare un disco con VeraCrypt e AES-256<\/a>. GPG ti chieder\u00e0 di inserire una passphrase due volte e produrr\u00e0 backup.tar.gpg<\/code>. La forma abbreviata del comando \u00e8 gpg -c backup.tar<\/code>.<\/p>\n\n\n\n
La sicurezza della cifratura simmetrica dipende interamente dalla forza della passphrase. AES-256 \u00e8 inviolabile con la forza bruta, ma una passphrase debole vanifica tutto. GPG applica una funzione di derivazione della chiave (KDF) per rallentare gli attacchi, eppure una passphrase di poche lettere resta indovinabile. Usa una frase lunga e casuale. Se vuoi capire cosa rende una passphrase realmente forte, leggi la nostra analisi sulla sicurezza delle password<\/a>.<\/p>\n\n\n\n
Per decifrare il file simmetrico, il comando \u00e8 lo stesso della cifratura asimmetrica, perch\u00e9 GPG riconosce automaticamente il tipo:<\/p>\n\n\n\n
gpg --decrypt backup.tar.gpg > backup.tar<\/code><\/pre>\n\n\n\n
Un uso elegante della cifratura simmetrica \u00e8 la pipe con altri comandi. Puoi cifrare al volo l’output di un backup senza creare file intermedi non cifrati su disco, riducendo la superficie di esposizione:<\/p>\n\n\n\n
tar czf - ~\/documenti | gpg -c --cipher-algo AES256 -o documenti.tar.gz.gpg<\/code><\/pre>\n\n\n\n
Step 9: Firme digitali e verifica<\/h2>\n\n\n\n
Le firme digitali dimostrano due cose: che un file proviene da te e che non \u00e8 stato alterato. GPG offre tre modalit\u00e0 di firma, ognuna con un uso diverso. La firma standard incorpora il documento nel file firmato e lo comprime:<\/p>\n\n\n\n
gpg --sign documento.txt          # produce documento.txt.gpg (binario)<\/code><\/pre>\n\n\n\n
La firma in chiaro (clearsign) mantiene il testo leggibile e aggiunge la firma in coda, perfetta per email e messaggi su forum:<\/p>\n\n\n\n
gpg --clearsign comunicato.txt    # produce comunicato.txt.asc leggibile<\/code><\/pre>\n\n\n\n
La firma separata (detached) \u00e8 la pi\u00f9 usata per il software. Crea un file di firma indipendente che accompagna il file originale senza modificarlo, ideale per verificare archivi, ISO e rilasci:<\/p>\n\n\n\n
gpg --detach-sign --armor release-v2.tar.gz   # produce release-v2.tar.gz.asc<\/code><\/pre>\n\n\n\n
Chiunque abbia la tua chiave pubblica verifica la firma separata fornendo entrambi i file. Questo \u00e8 esattamente il meccanismo con cui verifichi l’autenticit\u00e0 degli aggiornamenti software e delle immagini delle distribuzioni Linux:<\/p>\n\n\n\n
gpg --verify release-v2.tar.gz.asc release-v2.tar.gz<\/code><\/pre>\n\n\n\n
Un esito positivo mostra l’identit\u00e0 del firmatario e la conferma della validit\u00e0. Attenzione alla riga di avvertimento che pu\u00f2 comparire anche quando la firma \u00e8 matematicamente valida:<\/p>\n\n\n\n
gpg: Firma effettuata gio 13 giu 2026 10:42:18 CEST\ngpg:                con chiave EDDSA 0x4F2A9C1B8E7D5A30\ngpg: Firma valida da \"Mario Rossi <mario@example.it>\"\ngpg: ATTENZIONE: questa chiave non ha una firma affidabile!\ngpg:          non c'e' indicazione che la firma appartenga al proprietario.<\/code><\/pre>\n\n\n\n
Quell’avvertimento non significa che la firma sia falsa. Significa che non hai certificato la chiave del firmatario come affidabile (vedi Step 6). La firma \u00e8 valida matematicamente, ma GPG ti ricorda che non hai verificato l’identit\u00e0 dietro la chiave. Per i tuoi contatti verificati l’avvertimento sparisce dopo che firmi la loro chiave. Tutto questo poggia sulle stesse basi matematiche descritte nella guida su SHA-256<\/a>, l’algoritmo di hash che riassume il documento prima della firma.<\/p>\n\n\n\n
Step 10: Sottochiavi, scadenza e rotazione<\/h2>\n\n\n\n
Un setup professionale di GPG separa la chiave primaria dalle sottochiavi operative. La chiave primaria serve solo a certificare la tua identit\u00e0 e a firmare le sottochiavi: \u00e8 la tua identit\u00e0 a lungo termine e va protetta al massimo, idealmente tenuta offline. Le sottochiavi<\/strong>, una per la firma e una per la cifratura, gestiscono il lavoro quotidiano e possono essere ruotate o revocate senza distruggere la tua identit\u00e0.<\/p>\n\n\n\n
Per gestire le sottochiavi entra nell’editor interattivo della chiave:<\/p>\n\n\n\n
gpg --expert --edit-key 0x4F2A9C1B8E7D5A30\n\n# Dentro il prompt gpg>:\ngpg> addkey          # aggiunge una sottochiave\ngpg> expire          # cambia la scadenza\ngpg> key 1           # seleziona una sottochiave\ngpg> revkey          # revoca la sottochiave selezionata\ngpg> save            # salva ed esci<\/code><\/pre>\n\n\n\n
La scadenza non \u00e8 un difetto, \u00e8 una rete di sicurezza. Una chiave con scadenza si disattiva da sola se la perdi o la dimentichi, evitando che resti valida per sempre nelle mani sbagliate. Quando una chiave si avvicina alla scadenza, basta estenderla: non devi generarne una nuova n\u00e9 perdere la rete di fiducia accumulata. Estendi la scadenza con il comando expire<\/code> nell’editor e poi ripubblica la chiave aggiornata sul keyserver.<\/p>\n\n\n\n
Lo schema pi\u00f9 sicuro consiste nel tenere la chiave primaria su un supporto offline (una chiavetta USB cifrata riposta in cassaforte) e nel portare con te solo le sottochiavi sul computer di lavoro. Per farlo esporti le sole sottochiavi:<\/p>\n\n\n\n
# Esporta solo le sottochiavi segrete (non la primaria)\ngpg --armor --export-secret-subkeys 0x4F2A9C1B8E7D5A30 > sottochiavi.asc<\/code><\/pre>\n\n\n\n
Se una sottochiave operativa viene compromessa, la revochi e ne generi una nuova senza intaccare l’identit\u00e0 primaria. Questo limita i danni e ti evita di ricostruire da zero tutte le firme di fiducia, che sono il capitale pi\u00f9 difficile da ricreare in OpenPGP.<\/p>\n\n\n\n
Step 11: GPG con YubiKey e smartcard<\/h2>\n\n\n\n
Il livello di sicurezza pi\u00f9 alto sposta la chiave privata su un dispositivo hardware. Una YubiKey<\/strong> o una smartcard OpenPGP genera e custodisce la chiave privata in un chip da cui non pu\u00f2 essere estratta. Le operazioni di firma e decifratura avvengono dentro il dispositivo: anche se il computer \u00e8 infetto, l’attaccante non pu\u00f2 copiare la chiave. Verifica che la smartcard sia riconosciuta:<\/p>\n\n\n\n
gpg --card-status<\/code><\/pre>\n\n\n\n
Se il demone delle smartcard funziona, vedrai i dati della carta, i suoi slot per le chiavi e i PIN configurati. Per spostare le tue sottochiavi sulla YubiKey, entra nell’editor della chiave e usa il comando keytocard<\/code> dopo aver selezionato ciascuna sottochiave:<\/p>\n\n\n\n
gpg --edit-key 0x4F2A9C1B8E7D5A30\ngpg> key 1\ngpg> keytocard      # sposta la sottochiave selezionata sulla card\ngpg> save<\/code><\/pre>\n\n\n\n
Attenzione: keytocard<\/code> trasferisce la chiave sul dispositivo e la rimuove dal disco. Esegui sempre un backup completo della chiave prima di questa operazione, altrimenti se la YubiKey si rompe perdi tutto. La nostra guida su le app di autenticazione<\/a> spiega perch\u00e9 l’hardware token resta il fattore pi\u00f9 robusto contro il furto di credenziali, e lo stesso principio vale per le chiavi GPG.<\/p>\n\n\n\n
Con la chiave sulla card, ogni firma o decifratura richiede l’inserimento fisico del PIN tramite pinentry. Dopo tre PIN errati la carta si blocca e serve il PIN amministratore per sbloccarla, una protezione contro i tentativi di forza bruta su un dispositivo rubato.<\/p>\n\n\n\n
Step 12: Automazione e backup completo<\/h2>\n\n\n\n
L’ultimo passaggio rende il setup sostenibile nel tempo. Inizia da un backup completo e cifrato dell’intero ambiente GPG, che include chiavi, fiducia e configurazione:<\/p>\n\n\n\n
# Backup completo della directory GnuPG\ntar czf - ~\/.gnupg | gpg -c --cipher-algo AES256 -o gnupg-backup.tar.gz.gpg\n\n# Esporta la base di dati della fiducia separatamente\ngpg --export-ownertrust > ownertrust.txt<\/code><\/pre>\n\n\n\n
Per l’automazione in script non interattivi, ad esempio backup pianificati o pipeline CI, usa la modalit\u00e0 batch. Evita di mettere la passphrase in chiaro negli script: passala da una variabile d’ambiente o da un gestore di segreti, e usa --pinentry-mode loopback<\/code> per leggere la passphrase senza aprire una finestra grafica:<\/p>\n\n\n\n
echo \"$GPG_PASSPHRASE\" | gpg --batch --yes \\\n    --pinentry-mode loopback \\\n    --passphrase-fd 0 \\\n    --symmetric --cipher-algo AES256 \\\n    -o backup-notturno.tar.gpg backup-notturno.tar<\/code><\/pre>\n\n\n\n
Per cifrare automaticamente i backup verso una chiave pubblica (senza passphrase interattiva, perch\u00e9 la chiave pubblica non ne richiede), uno script systemd o cron pu\u00f2 lanciare:<\/p>\n\n\n\n
gpg --batch --yes --trust-model always \\\n    --encrypt --recipient backup@example.it \\\n    -o \/mnt\/backup\/dati-$(date +%F).tar.gpg \/tmp\/dati.tar<\/code><\/pre>\n\n\n\n
Questo schema cifra automaticamente i backup notturni verso una chiave dedicata, la cui chiave privata resta su un sistema separato per il ripristino. \u00c8 lo stesso principio della cifratura applicativa che vedi nella guida su crittografia end-to-end in Node.js<\/a>: i dati nascono cifrati e restano illeggibili in transito e a riposo.<\/p>\n\n\n\n
OpenPGP nel 2026: RFC 9580 e la separazione LibrePGP<\/h2>\n\n\n\n
Capire lo standard sottostante aiuta a interpretare le scelte di GPG. Nel luglio 2024 l’IETF ha pubblicato RFC 9580<\/strong>, il nuovo standard OpenPGP noto come “crypto refresh”. Questo documento modernizza formati e algoritmi, introduce schemi di cifratura autenticata pi\u00f9 solidi e definisce la base su cui i client OpenPGP costruiranno nel resto del decennio.<\/p>\n\n\n\n
La pubblicazione di RFC 9580 ha per\u00f2 evidenziato una frattura nella comunit\u00e0. Alcuni sviluppatori, tra cui il team principale di GnuPG, hanno espresso disaccordo sulla direzione tecnica e hanno proposto un percorso alternativo chiamato LibrePGP<\/strong>. Il risultato pratico \u00e8 che esistono due specifiche in evoluzione parallela: OpenPGP secondo RFC 9580 e LibrePGP, con differenze su alcuni formati. Per l’utente quotidiano l’impatto \u00e8 limitato, perch\u00e9 GnuPG mantiene un’ampia compatibilit\u00e0, ma vale la pena conoscere il contesto quando incontri incompatibilit\u00e0 tra client diversi.<\/p>\n\n\n\n
Cosa significa in concreto per te nel 2026. Usa GnuPG nella serie stabile pi\u00f9 recente per la massima compatibilit\u00e0. Quando scambi chiavi e messaggi con interlocutori che usano client diversi, come Sequoia o OpenPGP.js, testa l’interoperabilit\u00e0 su un messaggio di prova prima di affidarti a comunicazioni critiche. E preferisci algoritmi ampiamente supportati (Ed25519, Curve25519, AES-256) che funzionano su entrambe le specifiche senza sorprese.<\/p>\n\n\n\n
La frammentazione non rende GPG insicuro. Le primitive crittografiche di base restano solide e condivise. Cambia solo il modo in cui alcuni metadati e formati vengono codificati, e i client maturi gestiscono entrambe le varianti. Se progetti sistemi che devono durare anni, scegli configurazioni conservative e documenta le versioni che usi.<\/p>\n\n\n\n
GPG e crittografia post-quantistica<\/h2>\n\n\n\n
La domanda pi\u00f9 frequente nel 2026 riguarda i computer quantistici. Un computer quantistico abbastanza potente romperebbe RSA e le curve ellittiche come Ed25519, su cui GPG si basa oggi. La minaccia non \u00e8 immediata, ma la strategia “raccogli ora, decifra dopo” rende urgente la transizione: dati cifrati oggi e intercettati potrebbero essere decifrati in futuro.<\/p>\n\n\n\n
Lo standard OpenPGP si sta muovendo verso algoritmi resistenti ai computer quantistici, in particolare gli schemi basati su reticoli come ML-KEM (l’algoritmo standardizzato dal NIST, derivato da Kyber). Il lavoro \u00e8 in corso e alcune implementazioni sperimentali stanno comparendo nei rami di sviluppo, ma per la serie stabile attuale conviene trattare il supporto post-quantistico come una funzionalit\u00e0 in maturazione pi\u00f9 che come una garanzia di produzione. Verifica sempre le note di rilascio della versione esatta che installi prima di affidarti a una cifratura “ibrida” classica pi\u00f9 post-quantistica.<\/p>\n\n\n\n
Cosa fare in pratica oggi. Per dati che devono restare segreti oltre il 2035, valuta strati di protezione aggiuntivi e mantieni i sistemi aggiornati per adottare le chiavi post-quantistiche appena saranno stabili. Per i dati comuni, le chiavi Ed25519 e RSA-4096 restano sicure per anni. Il nostro approfondimento sulla crittografia e le funzioni di fiducia digitale<\/a> inquadra la transizione post-quantistica nel contesto pi\u00f9 ampio dell’ecosistema crittografico.<\/p>\n\n\n\n
6 errori comuni da evitare con GPG<\/h2>\n\n\n\n
Questi sono gli sbagli che si ripetono pi\u00f9 spesso e che rendono GPG meno sicuro o frustrante da usare. Conoscerli in anticipo ti risparmia problemi seri.<\/p>\n\n\n\n