GPG: Cifrare e Firmare File in 12 Step [2026]

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

Questa guida pratica copre l’intero ciclo di vita con GPG: 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.

Aggiornata al 13 giugno 2026, la guida include le novità del 2025 e 2026: il nuovo standard OpenPGP 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.

Che cos’è GPG e perché usarlo nel 2026

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

Il principio è la crittografia asimmetrica. Ogni utente possiede due chiavi matematicamente collegate: una chiave pubblica, che distribuisci liberamente, e una chiave privata, 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ò 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, garantisce riservatezza, autenticità e integrità in un solo strumento.

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 è più semplice e portabile di soluzioni proprietarie.

La differenza rispetto ad altri strumenti sta nel modello di fiducia decentralizzato. Non esiste un’autorità 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 spiega il modello opposto, quello delle autorità di certificazione.

GPG non è 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ù solido e diffuso. Questa guida ti porta da zero a un setup professionale.

Prerequisiti e versioni aggiornate al 2026

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

La tabella seguente elenca i componenti principali dello stack GnuPG con le versioni pubblicate sulla pagina di download ufficiale a giugno 2026. GPG non è 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.

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

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

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 è 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.

Step 1: Installare GnuPG su Linux, macOS e Windows

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.

Su Debian, Ubuntu e derivate installa il pacchetto completo, che include gli strumenti per le smartcard e i moduli di rete per i keyserver:

# Debian / Ubuntu
sudo apt update
sudo apt install gnupg gnupg-agent scdaemon

# Fedora / RHEL
sudo dnf install gnupg2

# Arch Linux
sudo pacman -S gnupg

# macOS con Homebrew
brew install gnupg pinentry-mac

Su Windows scarica l’installer di Gpg4win dal sito ufficiale ed esegui il setup grafico. Il pacchetto registra il comando gpg nel PATH, quindi potrai usarlo sia da PowerShell sia dall’interfaccia Kleopatra. Su macOS, se preferisci un’esperienza integrata con interfaccia grafica, installa GPG Suite invece di Homebrew.

Subito dopo l’installazione verifica che tutto sia a posto:

gpg --version

L’output mostra la versione del programma e gli algoritmi supportati:

gpg (GnuPG) 2.5.20
libgcrypt 1.12.2
Copyright (C) 2026 g10 Code GmbH
...
Algoritmi supportati:
Chiave pubblica: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cifratura: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compressione: Non compresso, ZIP, ZLIB, BZIP2

Controlla due cose nell’output. La prima: la riga EDDSA e ECDH negli algoritmi a chiave pubblica conferma il supporto alle curve moderne come Ed25519 e Curve25519, quelle che useremo. La seconda: AES256 tra le cifrature simmetriche. Se vedi una versione 2.2.x o precedente, il sistema operativo è datato e alcune funzionalità potrebbero mancare. In quel caso valuta l’aggiornamento del sistema o l’installazione dai sorgenti.

Una nota per chi usa Windows: il supporto ufficiale di alcuni strumenti correlati alla riga di comando è stato interrotto su quella piattaforma, ma GnuPG su Windows tramite Gpg4win resta pienamente mantenuto. Non confondere lo stato dei diversi progetti.

Step 2: Configurare gpg-agent e pinentry

Prima di generare chiavi vale la pena configurare l’ambiente. gpg-agent è il demone che gestisce le chiavi private in memoria e ti evita di reinserire la passphrase a ogni operazione. Il programma pinentry è quello che mostra la finestra (grafica o testuale) in cui digiti la passphrase. Quando questi due componenti non collaborano nascono molti errori comuni.

Crea la directory di configurazione con i permessi corretti. La cartella ~/.gnupg deve essere accessibile solo dal tuo utente, altrimenti GPG si rifiuta di funzionare per ragioni di sicurezza:

mkdir -p ~/.gnupg
chmod 700 ~/.gnupg

Configura gpg-agent creando il file ~/.gnupg/gpg-agent.conf. Le righe seguenti impostano una cache della passphrase di due ore e specificano il programma pinentry. Su macOS usa pinentry-mac, su Linux con interfaccia grafica pinentry-gnome3 o pinentry-qt, in ambienti solo testo pinentry-curses:

# ~/.gnupg/gpg-agent.conf
default-cache-ttl 7200
max-cache-ttl 28800
pinentry-program /usr/bin/pinentry-curses

# Su macOS:
# pinentry-program /opt/homebrew/bin/pinentry-mac

Imposta poi alcuni valori predefiniti per le preferenze degli algoritmi nel file ~/.gnupg/gpg.conf. 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:

# ~/.gnupg/gpg.conf
personal-cipher-preferences AES256 AES192 AES
personal-digest-preferences SHA512 SHA384 SHA256
cert-digest-algo SHA512
default-preference-list SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
keyid-format 0xlong
with-fingerprint
no-emit-version
no-comments

Dopo aver modificato la configurazione, riavvia l’agent perché legga i nuovi valori:

gpgconf --kill gpg-agent
gpg-connect-agent /bye

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ù deboli, e il formato esteso dei key ID previene gli attacchi basati su collisioni di identificatori brevi. Se vuoi capire meglio perché SHA-512 conta, leggi la nostra spiegazione su come funzionano le funzioni hash crittografiche.

Step 3: Generare una coppia di chiavi Ed25519

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ù piccole e operazioni più rapide. Una chiave Ed25519 da 256 bit fornisce una robustezza paragonabile a una RSA da circa 3072 bit, ma è enormemente più veloce.

Il modo più controllato per generare le chiavi è la modalità interattiva avanzata, che ti permette di scegliere l’algoritmo:

gpg --full-generate-key --expert

GPG ti chiederà 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à una passphrase robusta: questa è l’ultima linea di difesa se qualcuno copia il tuo file di chiave privata.

Per chi preferisce un comando rapido e non interattivo, la modalità 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:

# Chiave primaria Ed25519 valida 2 anni
gpg --quick-generate-key "Mario Rossi <[email protected]>" ed25519 sign 2y

# Aggiungi una sottochiave di cifratura Curve25519
gpg --quick-add-key TUO_FINGERPRINT cv25519 encrypt 2y

Sostituisci TUO_FINGERPRINT con l’impronta completa della chiave appena creata, che recuperi con gpg --list-keys --with-colons. Una volta generate le chiavi, verifica il risultato:

gpg --list-secret-keys --keyid-format=long

L’output mostra la chiave primaria (sec), la sottochiave (ssb), l’identità utente (uid) e l’impronta a 40 caratteri esadecimali:

sec   ed25519/0x4F2A9C1B8E7D5A30 2026-06-13 [SC] [scade: 2028-06-12]
      A1B2C3D4E5F60718293A4B5C6D7E8F904F2A9C1B
uid                 [  assoluta ] Mario Rossi <[email protected]>
ssb   cv25519/0x9D3E1F7A2C8B6045 2026-06-13 [E] [scade: 2028-06-12]

I codici tra parentesi quadre indicano le capacità: S per firma, C per certificazione, E per cifratura. La chiave primaria firma e certifica, la sottochiave cifra. L’impronta completa (la riga di 40 caratteri) è il dato da condividere e verificare di persona: il key ID breve può essere falsificato, l’impronta completa no.

Se hai bisogno della massima compatibilità con sistemi datati, puoi ancora generare chiavi RSA 4096. La tabella seguente confronta le opzioni così scegli con cognizione di causa.

Tipo di chiave	Dimensione	Velocità	Compatibilità	Quando usarla
Ed25519 / Curve25519	256 bit	Molto alta	Buona (GPG 2.1+)	Scelta predefinita nel 2026
RSA 4096	4096 bit	Bassa	Massima	Sistemi legacy o hardware datato
RSA 3072	3072 bit	Media	Massima	Compromesso compatibilità/prestazioni
NIST P-256	256 bit	Alta	Buona	Requisiti di conformità FIPS
RSA 2048	2048 bit	Media	Massima	Sconsigliata per nuove chiavi

Step 4: Creare il certificato di revoca

Questo passaggio sembra noioso e viene saltato di continuo. È l’errore più costoso che puoi commettere con GPG. Il certificato di revoca è 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é non scade, e nessuno può fermarla.

Il punto cruciale è generare il certificato di revoca subito, quando hai ancora accesso alla chiave privata e ricordi la passphrase. Se aspetti il momento in cui ti serve davvero, sarà troppo tardi. Genera il certificato così:

gpg --output ~/revoca-mario.asc --gen-revoke 0x4F2A9C1B8E7D5A30

GPG ti chiederà il motivo della revoca. Per un certificato preventivo scegli “nessun motivo specificato” o “la chiave è stata compromessa”. Inserisci la passphrase e otterrai un file ASCII. Il contenuto assomiglia a questo:

-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: Questo e' un certificato di revoca

iHgEIBYIACAWIQShssPU5fYHGCk6S1xtfo+QTyqcGwUCZ...
...
=aB3x
-----END PGP PUBLIC KEY BLOCK-----

Ora la parte delicata: dove conservarlo. Questo file ha lo stesso potere distruttivo di un comando di cancellazione. Chiunque lo possieda può revocare la tua chiave. Conservalo su una chiavetta USB cifrata, stampato in cassaforte o in un password manager sicuro. Non lasciarlo nella cartella ~/.gnupg accanto alla chiave: se perdi quella directory, perdi anche il certificato.

Se un giorno dovrai usarlo, lo importi e lo pubblichi sui keyserver con due comandi:

gpg --import ~/revoca-mario.asc
gpg --keyserver hkps://keys.openpgp.org --send-keys 0x4F2A9C1B8E7D5A30

Da quel momento chiunque scarichi la tua chiave vedrà che è revocata e smetterà di usarla per cifrare nuovi messaggi. La revoca è permanente e non si annulla, quindi usala solo quando serve davvero.

Step 5: Esportare e pubblicare la chiave pubblica

La chiave pubblica esiste per essere distribuita. Più persone la hanno, più persone possono inviarti messaggi cifrati e verificare le tue firme. Esportala in formato ASCII (detto “armatura”) con l’opzione --armor, che produce testo leggibile invece di dati binari, comodo da incollare in email e pagine web:

# Esporta la chiave pubblica in formato testo
gpg --armor --export 0x4F2A9C1B8E7D5A30 > mario-pubblica.asc

# Esporta la chiave privata per il backup (custodiscila!)
gpg --armor --export-secret-keys 0x4F2A9C1B8E7D5A30 > mario-privata.asc

Il file della chiave pubblica inizia con -----BEGIN PGP PUBLIC KEY BLOCK----- e puoi condividerlo senza timori. Il file della chiave privata, invece, va trattato come il segreto più prezioso che hai: cifralo, mettilo su supporto offline e non caricarlo mai online.

Keyserver moderni e WKD

Per anni i keyserver SKS hanno permesso di cercare chiavi per email. Quella rete è ormai deprecata: soffriva di attacchi di “avvelenamento” delle chiavi e di problemi di manutenzione, e oggi è praticamente abbandonata. Il keyserver di riferimento nel 2026 è keys.openpgp.org, che verifica le email prima di pubblicare gli indirizzi e non accetta firme di terzi non richieste. Pubblica la tua chiave così:

gpg --keyserver hkps://keys.openpgp.org --send-keys 0x4F2A9C1B8E7D5A30

L’alternativa più robusta è Web Key Directory (WKD), un meccanismo che pubblica la chiave su un percorso standard del tuo dominio web. Quando qualcuno cifra un messaggio per [email protected], il suo client GPG scarica automaticamente la chiave da example.it senza bisogno di keyserver. È il modo più affidabile per distribuire chiavi a chi possiede un dominio proprio, ed è il metodo che la nostra guida su Proton Mail e Tuta menziona per l’interoperabilità tra provider di posta cifrata.

Step 6: Importare e verificare le chiavi altrui

Per cifrare un file destinato a qualcuno, ti serve la sua chiave pubblica. Importarla è banale; verificarla è il passaggio che la gente salta e che invece determina se GPG ti protegge davvero. Importa una chiave ricevuta come file:

gpg --import chiave-di-anna.asc

Oppure scaricala da un keyserver cercando per email o impronta:

gpg --keyserver hkps://keys.openpgp.org --search-keys [email protected]
# oppure cercala tramite WKD del suo dominio
gpg --locate-keys [email protected]

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à verificato. Mostra l’impronta così:

gpg --fingerprint [email protected]

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à:

gpg --sign-key [email protected]

Questo è il modello di fiducia decentralizzato di OpenPGP, storicamente chiamato “rete di fiducia” (web of trust). A differenza dei certificati TLS verificati da un’autorità centrale, qui sei tu a decidere di chi fidarti. Il confronto delle impronte è 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.

Step 7: Cifrare un file con la chiave pubblica

Con le chiavi pronte, cifrare è semplice. La cifratura asimmetrica usa la chiave pubblica del destinatario, così solo lui potrà decifrare con la sua chiave privata. Cifra un file per Anna:

# Cifratura binaria (produce contratto.pdf.gpg)
gpg --encrypt --recipient [email protected] contratto.pdf

# Cifratura in formato testo ASCII (produce contratto.pdf.asc)
gpg --encrypt --armor --recipient [email protected] contratto.pdf

Spesso vuoi cifrare un file in modo che tu stesso possa rileggerlo, oltre al destinatario. Per impostazione predefinita un file cifrato solo per Anna non è leggibile nemmeno da te. Aggiungi te stesso tra i destinatari:

gpg --encrypt --armor \
    --recipient [email protected] \
    --recipient [email protected] \
    contratto.pdf

La combinazione più usata nella pratica è cifrare e firmare in un solo comando. Così Anna riceve un file riservato che può anche verificare provenire davvero da te:

gpg --encrypt --sign --armor --recipient [email protected] contratto.pdf

Per decifrare un file ricevuto, Anna esegue semplicemente:

gpg --decrypt contratto.pdf.asc > contratto.pdf

GPG le chiederà la passphrase, decifrerà il contenuto e, se il file era anche firmato, mostrerà l’esito della verifica della firma. Un output di successo riporta qualcosa del tipo: gpg: Firma valida da "Mario Rossi". Se la firma non è valida, GPG lo segnala in modo evidente e dovresti trattare il file come sospetto.

Step 8: Cifratura simmetrica con passphrase

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 è più pratica. Usa una sola passphrase, senza chiavi pubbliche, e chiunque conosca la passphrase può decifrare. Il comando è breve:

gpg --symmetric --cipher-algo AES256 backup.tar

L’opzione --cipher-algo AES256 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. GPG ti chiederà di inserire una passphrase due volte e produrrà backup.tar.gpg. La forma abbreviata del comando è gpg -c backup.tar.

La sicurezza della cifratura simmetrica dipende interamente dalla forza della passphrase. AES-256 è 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.

Per decifrare il file simmetrico, il comando è lo stesso della cifratura asimmetrica, perché GPG riconosce automaticamente il tipo:

gpg --decrypt backup.tar.gpg > backup.tar

Un uso elegante della cifratura simmetrica è 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:

tar czf - ~/documenti | gpg -c --cipher-algo AES256 -o documenti.tar.gz.gpg

Step 9: Firme digitali e verifica

Le firme digitali dimostrano due cose: che un file proviene da te e che non è stato alterato. GPG offre tre modalità di firma, ognuna con un uso diverso. La firma standard incorpora il documento nel file firmato e lo comprime:

gpg --sign documento.txt          # produce documento.txt.gpg (binario)

La firma in chiaro (clearsign) mantiene il testo leggibile e aggiunge la firma in coda, perfetta per email e messaggi su forum:

gpg --clearsign comunicato.txt    # produce comunicato.txt.asc leggibile

La firma separata (detached) è la più usata per il software. Crea un file di firma indipendente che accompagna il file originale senza modificarlo, ideale per verificare archivi, ISO e rilasci:

gpg --detach-sign --armor release-v2.tar.gz   # produce release-v2.tar.gz.asc

Chiunque abbia la tua chiave pubblica verifica la firma separata fornendo entrambi i file. Questo è esattamente il meccanismo con cui verifichi l’autenticità degli aggiornamenti software e delle immagini delle distribuzioni Linux:

gpg --verify release-v2.tar.gz.asc release-v2.tar.gz

Un esito positivo mostra l’identità del firmatario e la conferma della validità. Attenzione alla riga di avvertimento che può comparire anche quando la firma è matematicamente valida:

gpg: Firma effettuata gio 13 giu 2026 10:42:18 CEST
gpg:                con chiave EDDSA 0x4F2A9C1B8E7D5A30
gpg: Firma valida da "Mario Rossi <[email protected]>"
gpg: ATTENZIONE: questa chiave non ha una firma affidabile!
gpg:          non c'e' indicazione che la firma appartenga al proprietario.

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 è valida matematicamente, ma GPG ti ricorda che non hai verificato l’identità 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, l’algoritmo di hash che riassume il documento prima della firma.

Step 10: Sottochiavi, scadenza e rotazione

Un setup professionale di GPG separa la chiave primaria dalle sottochiavi operative. La chiave primaria serve solo a certificare la tua identità e a firmare le sottochiavi: è la tua identità a lungo termine e va protetta al massimo, idealmente tenuta offline. Le sottochiavi, una per la firma e una per la cifratura, gestiscono il lavoro quotidiano e possono essere ruotate o revocate senza distruggere la tua identità.

Per gestire le sottochiavi entra nell’editor interattivo della chiave:

gpg --expert --edit-key 0x4F2A9C1B8E7D5A30

# Dentro il prompt gpg>:
gpg> addkey          # aggiunge una sottochiave
gpg> expire          # cambia la scadenza
gpg> key 1           # seleziona una sottochiave
gpg> revkey          # revoca la sottochiave selezionata
gpg> save            # salva ed esci

La scadenza non è un difetto, è 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é perdere la rete di fiducia accumulata. Estendi la scadenza con il comando expire nell’editor e poi ripubblica la chiave aggiornata sul keyserver.

Lo schema più 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:

# Esporta solo le sottochiavi segrete (non la primaria)
gpg --armor --export-secret-subkeys 0x4F2A9C1B8E7D5A30 > sottochiavi.asc

Se una sottochiave operativa viene compromessa, la revochi e ne generi una nuova senza intaccare l’identità primaria. Questo limita i danni e ti evita di ricostruire da zero tutte le firme di fiducia, che sono il capitale più difficile da ricreare in OpenPGP.

Step 11: GPG con YubiKey e smartcard

Il livello di sicurezza più alto sposta la chiave privata su un dispositivo hardware. Una YubiKey o una smartcard OpenPGP genera e custodisce la chiave privata in un chip da cui non può essere estratta. Le operazioni di firma e decifratura avvengono dentro il dispositivo: anche se il computer è infetto, l’attaccante non può copiare la chiave. Verifica che la smartcard sia riconosciuta:

gpg --card-status

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 dopo aver selezionato ciascuna sottochiave:

gpg --edit-key 0x4F2A9C1B8E7D5A30
gpg> key 1
gpg> keytocard      # sposta la sottochiave selezionata sulla card
gpg> save

Attenzione: keytocard 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 spiega perché l’hardware token resta il fattore più robusto contro il furto di credenziali, e lo stesso principio vale per le chiavi GPG.

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.

Step 12: Automazione e backup completo

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:

# Backup completo della directory GnuPG
tar czf - ~/.gnupg | gpg -c --cipher-algo AES256 -o gnupg-backup.tar.gz.gpg

# Esporta la base di dati della fiducia separatamente
gpg --export-ownertrust > ownertrust.txt

Per l’automazione in script non interattivi, ad esempio backup pianificati o pipeline CI, usa la modalità 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 per leggere la passphrase senza aprire una finestra grafica:

echo "$GPG_PASSPHRASE" | gpg --batch --yes \
    --pinentry-mode loopback \
    --passphrase-fd 0 \
    --symmetric --cipher-algo AES256 \
    -o backup-notturno.tar.gpg backup-notturno.tar

Per cifrare automaticamente i backup verso una chiave pubblica (senza passphrase interattiva, perché la chiave pubblica non ne richiede), uno script systemd o cron può lanciare:

gpg --batch --yes --trust-model always \
    --encrypt --recipient [email protected] \
    -o /mnt/backup/dati-$(date +%F).tar.gpg /tmp/dati.tar

Questo schema cifra automaticamente i backup notturni verso una chiave dedicata, la cui chiave privata resta su un sistema separato per il ripristino. È lo stesso principio della cifratura applicativa che vedi nella guida su crittografia end-to-end in Node.js: i dati nascono cifrati e restano illeggibili in transito e a riposo.

OpenPGP nel 2026: RFC 9580 e la separazione LibrePGP

Capire lo standard sottostante aiuta a interpretare le scelte di GPG. Nel luglio 2024 l’IETF ha pubblicato RFC 9580, il nuovo standard OpenPGP noto come “crypto refresh”. Questo documento modernizza formati e algoritmi, introduce schemi di cifratura autenticata più solidi e definisce la base su cui i client OpenPGP costruiranno nel resto del decennio.

La pubblicazione di RFC 9580 ha però evidenziato una frattura nella comunità. Alcuni sviluppatori, tra cui il team principale di GnuPG, hanno espresso disaccordo sulla direzione tecnica e hanno proposto un percorso alternativo chiamato LibrePGP. Il risultato pratico è che esistono due specifiche in evoluzione parallela: OpenPGP secondo RFC 9580 e LibrePGP, con differenze su alcuni formati. Per l’utente quotidiano l’impatto è limitato, perché GnuPG mantiene un’ampia compatibilità, ma vale la pena conoscere il contesto quando incontri incompatibilità tra client diversi.

Cosa significa in concreto per te nel 2026. Usa GnuPG nella serie stabile più recente per la massima compatibilità. Quando scambi chiavi e messaggi con interlocutori che usano client diversi, come Sequoia o OpenPGP.js, testa l’interoperabilità 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.

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.

GPG e crittografia post-quantistica

La domanda più 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 è immediata, ma la strategia “raccogli ora, decifra dopo” rende urgente la transizione: dati cifrati oggi e intercettati potrebbero essere decifrati in futuro.

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 è 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à in maturazione più 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ù post-quantistica.

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 inquadra la transizione post-quantistica nel contesto più ampio dell’ecosistema crittografico.

6 errori comuni da evitare con GPG

Questi sono gli sbagli che si ripetono più spesso e che rendono GPG meno sicuro o frustrante da usare. Conoscerli in anticipo ti risparmia problemi seri.

Non creare il certificato di revoca. Senza certificato di revoca, una chiave compromessa o persa resta valida fino alla scadenza. Generalo subito dopo la creazione delle chiavi e conservalo offline.
Non verificare le impronte. Importare una chiave non significa fidarsi. Senza confrontare l’impronta a 40 caratteri tramite un canale separato, sei esposto a un attacco man in the middle.
Permessi sbagliati su ~/.gnupg. Se la directory non è impostata a 700 e i file a 600, GPG mostra avvisi o si rifiuta di funzionare. Correggi con chmod 700 ~/.gnupg.
Passphrase deboli. AES-256 è inutile dietro una passphrase di sei caratteri. La cifratura simmetrica è forte solo quanto la frase segreta che scegli.
Tenere la chiave privata online senza backup. Se perdi ~/.gnupg senza backup, perdi l’identità per sempre. Se la tieni su un cloud non cifrato, la regali a chi viola l’account.
Chiavi senza scadenza. Una chiave eterna che non controlli più resta valida indefinitamente. Imposta sempre una scadenza ed estendila quando serve.

Risoluzione dei problemi: 8 errori frequenti

Quando GPG smette di funzionare, il problema è quasi sempre nell’agent, nei permessi o nel pinentry. La tabella riassume i messaggi di errore più comuni e la loro soluzione.

Errore	Causa	Soluzione
`Inappropriate ioctl for device`	pinentry non trova un terminale	Esegui `export GPG_TTY=$(tty)` nel profilo della shell
`No pinentry`	Programma pinentry mancante o non configurato	Installa pinentry e indicane il percorso in gpg-agent.conf
`Agent refused operation`	gpg-agent bloccato o cache corrotta	`gpgconf --kill gpg-agent` e riprova
`unsafe permissions on homedir`	Permessi errati su ~/.gnupg	`chmod 700 ~/.gnupg` e poi `chmod 600 ~/.gnupg/*`
`No secret key`	Chiave privata assente o non importata	Importa la chiave privata o verifica con `--list-secret-keys`
`decryption failed: No secret key`	File cifrato per un destinatario diverso	Serve la chiave privata del destinatario corretto
`keyserver receive failed`	Keyserver SKS deprecato o rete bloccata	Usa `hkps://keys.openpgp.org` sulla porta 443
`WARNING: unsafe ownership`	La directory appartiene a un altro utente	`chown -R $USER ~/.gnupg`

Due trucchi diagnostici risolvono la maggior parte dei casi ostinati. Il primo: imposta sempre la variabile GPG_TTY aggiungendola al file ~/.bashrc o ~/.zshrc, perché senza di essa pinentry fallisce silenziosamente in molti contesti, specialmente in SSH e negli script. Il secondo: quando un comando si comporta in modo strano, aggiungi --verbose o addirittura --debug-level guru per vedere esattamente cosa GPG sta tentando di fare.

# Aggiungi al profilo della shell per evitare errori di pinentry
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc
source ~/.bashrc

# Riavvio completo dell'agent quando nulla funziona
gpgconf --kill all
gpg-connect-agent reloadagent /bye

Se il problema persiste su una smartcard, controlla che scdaemon sia installato e che nessun altro processo (come un’app del gestore della YubiKey) tenga occupato il lettore. Solo un programma alla volta può accedere alla card.

Consigli avanzati per un setup professionale

Una volta padroneggiate le basi, alcune pratiche distinguono un uso amatoriale da uno professionale. Queste tecniche valgono soprattutto per chi gestisce firme di software, rilasci o segreti aziendali.

Firmare i commit Git con GPG

Firmare i commit dimostra che il codice proviene davvero da te e impedisce che qualcuno spacci modifiche a tuo nome. Configura Git per usare la tua sottochiave di firma e abilita la firma automatica:

git config --global user.signingkey 0x4F2A9C1B8E7D5A30
git config --global commit.gpgsign true
git config --global gpg.program gpg

Da quel momento ogni commit porta una firma verificabile, e piattaforme come GitHub e GitLab mostrano un badge “Verified” accanto ai tuoi contributi quando carichi la chiave pubblica nel profilo.

Cifrare segreti nei repository

Per conservare segreti (chiavi API, password di servizio) in un repository condiviso senza esporli, GPG cifra i file verso le chiavi pubbliche del team. Strumenti come git-crypt e SOPS si appoggiano a GPG per cifrare in modo trasparente solo i file sensibili, lasciando il resto del codice leggibile. Ogni membro decifra con la propria chiave privata, e revocare l’accesso a una persona significa ri-cifrare escludendo la sua chiave.

Un’ultima raccomandazione: documenta il tuo schema di chiavi. Annota quali sottochiavi usi per cosa, dove sono i backup e quando scadono. Quando gestisci più chiavi nel tempo, la confusione è il vero nemico della sicurezza. Per il quadro completo della crittografia applicata, la nostra guida sulla gestione di chiavi e certificati con OpenSSL mostra l’approccio complementare basato su X.509.

Domande frequenti su GPG

Qual è la differenza tra GPG, GnuPG, OpenPGP e PGP?

OpenPGP è lo standard aperto (definito in RFC 9580). GnuPG, abbreviato GPG, è l’implementazione libera e gratuita di quello standard, ed è quella che usiamo in questa guida. PGP era il software commerciale originale da cui tutto è nato negli anni Novanta. Nell’uso quotidiano GPG e GnuPG sono sinonimi.

GPG è sicuro nel 2026?

Sì, le primitive crittografiche di GPG (Ed25519, Curve25519, AES-256, SHA-512) restano robuste contro gli attacchi classici. I rischi reali non riguardano la matematica ma l’uso: passphrase deboli, chiavi non verificate e backup mancanti. La minaccia quantistica esiste ma non è ancora pratica, e lo standard si sta evolvendo verso algoritmi resistenti.

Quale algoritmo di chiave dovrei scegliere?

Nel 2026 la scelta predefinita è Ed25519 per la firma e Curve25519 per la cifratura: chiavi piccole, veloci e sicure, supportate da GnuPG 2.1 in poi. Scegli RSA 4096 solo se devi interagire con sistemi datati che non comprendono le curve ellittiche moderne.

Cosa succede se dimentico la passphrase?

Non esiste un modo per recuperare la passphrase: è una protezione, non un account che puoi reimpostare. Se la dimentichi, la chiave privata diventa inutilizzabile. Per questo serve il certificato di revoca creato in anticipo, che ti permette almeno di dichiarare pubblicamente non valida la chiave e generarne una nuova.

Posso usare la stessa chiave su più computer?

Sì. Esporta la chiave privata (o meglio le sole sottochiavi) e importala sull’altro dispositivo, oppure mettila su una YubiKey e portala con te. Per la sicurezza massima, esporta solo le sottochiavi con --export-secret-subkeys e tieni la chiave primaria offline su un unico supporto protetto.

GPG cifra anche l’oggetto delle email?

No, e questo è un limite noto. OpenPGP cifra il corpo del messaggio e gli allegati, ma l’oggetto, il mittente, il destinatario e gli altri metadati restano in chiaro. Se i metadati sono sensibili quanto il contenuto, valuta strumenti pensati per ridurli, come i provider di posta cifrata o le app di messaggistica end-to-end.

Devo usare un keyserver o WKD per pubblicare la chiave?

Se possiedi un dominio, Web Key Directory è la scelta più affidabile, perché lega la chiave al tuo dominio e i client la trovano da soli. Altrimenti usa keys.openpgp.org, che verifica gli indirizzi email. Evita i vecchi keyserver della rete SKS, ormai deprecati per problemi di avvelenamento delle chiavi.

Approfondimenti correlati

Fonti e risorse ufficiali

Articolo aggiornato al 13 giugno 2026. I comandi sono testati su GnuPG 2.5.x. Verifica sempre la versione installata con gpg --version, perché i pacchetti delle distribuzioni possono restare indietro rispetto agli ultimi rilasci ufficiali.