942 lines · plain
1.. include:: ../disclaimer-ita.rst2 3:Original: :ref:`Documentation/process/maintainer-pgp-guide.rst <pgpguide>`4:Translator: Alessia Mantegazza <amantegazza@vaga.pv.it>5 6.. _it_pgpguide:7 8=========================================9La guida a PGP per manutentori del kernel10=========================================11 12:Author: Konstantin Ryabitsev <konstantin@linuxfoundation.org>13 14Questo documento è destinato agli sviluppatori del kernel Linux, in particolar15modo ai manutentori. Contiene degli approfondimenti riguardo informazioni che16sono state affrontate in maniera più generale nella sezione17"`Protecting Code Integrity`_" pubblicata dalla Linux Foundation.18Per approfondire alcuni argomenti trattati in questo documento è consigliato19leggere il documento sopraindicato20 21.. _`Protecting Code Integrity`: https://github.com/lfit/itpol/blob/master/protecting-code-integrity.md22 23Il ruolo di PGP nello sviluppo del kernel Linux24===============================================25 26PGP aiuta ad assicurare l'integrità del codice prodotto dalla comunità27di sviluppo del kernel e, in secondo luogo, stabilisce canali di comunicazione28affidabili tra sviluppatori attraverso lo scambio di email firmate con PGP.29 30Il codice sorgente del kernel Linux è disponibile principalmente in due31formati:32 33- repositori distribuiti di sorgenti (git)34- rilasci periodici di istantanee (archivi tar)35 36Sia i repositori git che gli archivi tar portano le firme PGP degli37sviluppatori che hanno creato i rilasci ufficiali del kernel. Queste firme38offrono una garanzia crittografica che le versioni scaricabili rese disponibili39via kernel.org, o altri portali, siano identiche a quelle che gli sviluppatori40hanno sul loro posto di lavoro. A tal scopo:41 42- i repositori git forniscono firme PGP per ogni tag43- gli archivi tar hanno firme separate per ogni archivio44 45.. _it_devs_not_infra:46 47Fidatevi degli sviluppatori e non dell'infrastruttura48-----------------------------------------------------49 50Fin dal 2011, quando i sistemi di kernel.org furono compromessi, il principio51generale del progetto Kernel Archives è stato quello di assumere che qualsiasi52parte dell'infrastruttura possa essere compromessa in ogni momento. Per questa53ragione, gli amministratori hanno intrapreso deliberatemene dei passi per54enfatizzare che la fiducia debba risiedere sempre negli sviluppatori e mai nel55codice che gestisce l'infrastruttura, indipendentemente da quali che siano le56pratiche di sicurezza messe in atto.57 58Il principio sopra indicato è la ragione per la quale è necessaria questa59guida. Vogliamo essere sicuri che il riporre la fiducia negli sviluppatori60non sia fatto semplicemente per incolpare qualcun'altro per future falle di61sicurezza. L'obiettivo è quello di fornire una serie di linee guida che gli62sviluppatori possano seguire per creare un ambiente di lavoro sicuro e63salvaguardare le chiavi PGP usate nello stabilire l'integrità del kernel Linux64stesso.65 66.. _it_pgp_tools:67 68Strumenti PGP69=============70 71Usare GnuPG 2.2 o successivo72----------------------------73 74La vostra distribuzione potrebbe avere già installato GnuPG, dovete solo75verificare che stia utilizzando la versione abbastanza recente. Per controllate76usate::77 78 $ gpg --version | head -n179 80Se state utilizzando la version 2.2 o successiva, allora siete pronti a partire.81Se invece state usando una versione precedente, allora alcuni comandi elencati82in questa guida potrebbero non funzionare.83 84Configurare le opzioni di gpg-agent85~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~86 87L'agente GnuPG è uno strumento di aiuto che partirà automaticamente ogni volta88che userete il comando ``gpg`` e funzionerà in *background* con l'obiettivo di89individuare la passphrase. Ci sono due opzioni che dovreste conoscere90per personalizzare la scadenza della passphrase nella cache:91 92- ``default-cache-ttl`` (secondi): Se usate ancora la stessa chiave prima93 che il time-to-live termini, il conto alla rovescia si resetterà per un94 altro periodo. Di base è di 600 (10 minuti).95 96- ``max-cache-ttl`` (secondi): indipendentemente da quanto sia recente l'ultimo97 uso della chiave da quando avete inserito la passphrase, se il massimo98 time-to-live è scaduto, dovrete reinserire nuovamente la passphrase.99 Di base è di 30 minuti.100 101Se ritenete entrambe questi valori di base troppo corti (o troppo lunghi),102potete creare il vostro file ``~/.gnupg/gpg-agent.conf`` ed impostare i vostri103valori::104 105 # set to 30 minutes for regular ttl, and 2 hours for max ttl106 default-cache-ttl 1800107 max-cache-ttl 7200108 109.. note::110 111 Non è più necessario far partire l'agente gpg manualmente all'inizio della112 vostra sessione. Dovreste controllare i file rc per rimuovere tutto ciò che113 riguarda vecchie le versioni di GnuPG, poiché potrebbero non svolgere più114 bene il loro compito.115 116.. _it_protect_your_key:117 118Proteggere la vostra chiave PGP primaria119========================================120 121Questa guida parte dal presupposto che abbiate già una chiave PGP che usate122per lo sviluppo del kernel Linux. Se non ne avete ancora una, date uno sguardo123al documento "`Protecting Code Integrity`_" che abbiamo menzionato prima.124 125Dovreste inoltre creare una nuova chiave se quella attuale è inferiore a 2048126bit (RSA).127 128Le sottochiavi PGP129------------------130 131Raramente le chiavi PGP sono composte da una singola coppia -- solitamente, sono132una collezione di sottochiavi indipendenti usate per diversi scopi in funzione133delle capacità assegnate al momento della creazione. Una chiave PGP può avere134quattro capacità:135 136- **[S]** può essere usata per firmare137- **[E]** può essere usata per criptare138- **[A]** può essere usata per autenticare139- **[C]** può essere usata per certificare altre chiavi140 141La chiave con la capacità **[C]** viene spesso chiamata chiave "passepartout"142(*master key*), ma è una terminologia fuorviante perché lascia intendere che la143chiave di certificato possa essere usate in sostituzione delle altre (proprio144come le vere chiavi passpartout in grado di aprire diverse serrature). Dato che145questo non è il caso, per evitare fraintendimenti, in questa guida ci riferiremo146a questa chiave chiamandola "La chiave di certificazione".147 148I seguenti punti sono molto importanti:149 1501. Tutte le sottochiavi sono indipendenti. Se perdete una sottochiave privata151 non potrete recuperarla usando le altre.1522. Ad eccezione della chiave di certificazione, ci possono essere più153 sottochiavi con le stesse capacità (per esempio, potete avere 2 sottochiavi154 per criptare, 3 per firmare, ma solo una per una sola per certificare). Tutte155 le sottochiavi sono indipendenti -- un messaggio criptato usando una chiave156 **[E]** non può essere decriptato usano altre sottochiavi **[E]**.1573. Una sottochiave può avere più capacità (per esempio, la chiave **[C]** può158 anche essere una chiave **[S]**).159 160La chiave con capacità **[C]** (certificazione) è la sola che può essere usata161per indicare relazioni fra chiavi. Solo la chiave **[C]** può essere usata per:162 163- aggiungere o revocare altre chiavi (sottochiavi) che hanno capacità S/E/A;164- aggiungere, modificare o eliminare le identità (unids) associate alla chiave;165- aggiungere o modificare la propria data di scadenza o delle sottochiavi;166- firmare le chiavi di altre persone a scopo di creare una rete di fiducia.167 168Di base, alla creazione di nuove chiavi, GnuPG genera quanto segue:169 170- Una chiave la capacità di certificazione che quella di firma (**[SC]**)171- Una sottochiave separata con capacità di criptare (**[E]**)172 173 174 175 176Se avete usato i parametri predefiniti per generare la vostra chiave, quello177sarà il risultato. Potete verificarlo utilizzando ``gpg --list-secret-keys``,178per esempio::179 180 sec ed25519 2022-12-20 [SC] [expires: 2024-12-19]181 000000000000000000000000AAAABBBBCCCCDDDD182 uid [ultimate] Alice Dev <adev@kernel.org>183 ssb cv25519 2022-12-20 [E] [expires: 2024-12-19]184 185La lunga riga sotto la voce ``sec`` è la vostra impronta digitale --186negli esempi che seguono, quando vedere ``[fpr]`` ci si riferisce a questa187stringa di 40 caratteri.188 189Assicuratevi che la vostra passphrase sia forte190-----------------------------------------------191 192GnuPG utilizza le passphrases per criptare la vostra chiave privata prima193di salvarla sul disco. In questo modo, anche se il contenuto della vostra194cartella ``.gnupg`` venisse letto o trafugato nella sia interezza, gli195attaccanti non potrebbero comunque utilizzare le vostre chiavi private senza196aver prima ottenuto la passphrase per decriptarle.197 198È assolutamente essenziale che le vostre chiavi private siano protette da199una passphrase forte. Per impostarla o cambiarla, usate::200 201 $ gpg --change-passphrase [fpr]202 203Create una sottochiave di firma separata204----------------------------------------205 206Il nostro obiettivo è di proteggere la chiave primaria spostandola su un207dispositivo sconnesso dalla rete, dunque se avete solo una chiave combinata208**[SC]** allora dovreste creare una sottochiave di firma separata::209 210 $ gpg --quick-add-key [fpr] ed25519 sign211 212Ricordate di informare il keyserver del vostro cambiamento, cosicché altri213possano ricevere la vostra nuova sottochiave::214 215 $ gpg --send-key [fpr]216 217.. note:: Supporto ECC in GnuPG218 219 Tenete presente che se avete intenzione di usare un dispositivo che non220 supporta chiavi ED25519 ECC, allora dovreste usare "nistp256" al posto di221 "ed25519". Più avanti ci sono alcune raccomandazioni per i dispositivi.222 223Copia di riserva della chiave primaria per gestire il recupero da disastro224--------------------------------------------------------------------------225 226Maggiori sono le firme di altri sviluppatori che vengono applicate alla vostra,227maggiori saranno i motivi per avere una copia di riserva che non sia digitale,228al fine di effettuare un recupero da disastro.229 230Il modo migliore per creare una copia fisica della vostra chiave privata è231l'uso del programma ``paperkey``. Consultate ``man paperkey`` per maggiori232dettagli sul formato dell'output ed i suoi punti di forza rispetto ad altre233soluzioni. Paperkey dovrebbe essere già pacchettizzato per la maggior parte234delle distribuzioni.235 236Eseguite il seguente comando per creare una copia fisica di riserva della237vostra chiave privata::238 239 $ gpg --export-secret-key [fpr] | paperkey -o /tmp/key-backup.txt240 241Stampate il file (o fate un pipe direttamente verso lpr), poi prendete242una penna e scrivete la passphare sul margine del foglio. **Questo è243caldamente consigliato** perché la copia cartacea è comunque criptata con244la passphrase, e se mai doveste cambiarla non vi ricorderete qual'era al245momento della creazione di quella copia -- *garantito*.246 247Mettete la copia cartacea e la passphrase scritta a mano in una busta e248mettetela in un posto sicuro e ben protetto, preferibilmente fuori casa,249magari in una cassetta di sicurezza in banca.250 251.. note::252 253 Probabilmente la vostra stampante non è più quello stupido dispositivo254 connesso alla porta parallela, ma dato che il suo output è comunque255 criptato con la passphrase, eseguire la stampa in un sistema "cloud"256 moderno dovrebbe essere comunque relativamente sicuro.257 258Copia di riserva di tutta la cartella GnuPG259-------------------------------------------260 261.. warning::262 263 **!!!Non saltate questo passo!!!**264 265Quando avete bisogno di recuperare le vostre chiavi PGP è importante avere266una copia di riserva pronta all'uso. Questo sta su un diverso piano di267prontezza rispetto al recupero da disastro che abbiamo risolto con268``paperkey``. Vi affiderete a queste copie esterne quando dovreste usare la269vostra chiave Certify -- ovvero quando fate modifiche alle vostre chiavi o270firmate le chiavi di altre persone ad una conferenza o ad un gruppo d'incontro.271 272Incominciate con una piccola chiavetta di memoria USB (preferibilmente due)273che userete per le copie di riserva. Dovrete criptarle usando LUKS -- fate274riferimento alla documentazione della vostra distribuzione per capire come275fare.276 277Per la passphrase di criptazione, potete usare la stessa della vostra chiave278primaria.279 280Una volta che il processo di criptazione è finito, reinserite il disco USB ed281assicurativi che venga montato correttamente. Copiate interamente la cartella282``.gnugp`` nel disco criptato::283 284 $ cp -a ~/.gnupg /media/disk/foo/gnupg-backup285 286Ora dovreste verificare che tutto continui a funzionare::287 288 $ gpg --homedir=/media/disk/foo/gnupg-backup --list-key [fpr]289 290Se non vedete errori, allora dovreste avere fatto tutto con successo.291Smontate il disco USB, etichettatelo per bene di modo da evitare di292distruggerne il contenuto non appena vi serve una chiavetta USB a caso, ed293infine mettetelo in un posto sicuro -- ma non troppo lontano, perché vi servirà294di tanto in tanto per modificare le identità, aggiungere o revocare295sottochiavi, o firmare le chiavi di altre persone.296 297Togliete la chiave primaria dalla vostra home298---------------------------------------------299 300I file che si trovano nella vostra cartella home non sono poi così ben protetti301come potreste pensare. Potrebbero essere letti o trafugati in diversi modi:302 303- accidentalmente quando fate una rapida copia della cartella home per304 configurare una nuova postazione305- da un amministratore di sistema negligente o malintenzionato306- attraverso copie di riserva insicure307- attraverso malware installato in alcune applicazioni (browser, lettori PDF,308 eccetera)309- attraverso coercizione quando attraversate confini internazionali310 311Proteggere la vostra chiave con una buona passphare aiuta notevolmente a312ridurre i rischi elencati qui sopra, ma le passphrase possono essere scoperte313attraverso i keylogger, il shoulder-surfing, o altri modi. Per questi motivi,314nella configurazione si raccomanda di rimuove la chiave primaria dalla vostra315cartella home e la si archivia su un dispositivo disconnesso.316 317.. warning::318 319 Per favore, fate riferimento alla sezione precedente e assicuratevi320 di aver fatto una copia di riserva totale della cartella GnuPG. Quello321 che stiamo per fare renderà la vostra chiave inutile se non avete delle322 copie di riserva utilizzabili!323 324Per prima cosa, identificate il keygrip della vostra chiave primaria::325 326 $ gpg --with-keygrip --list-key [fpr]327 328L'output assomiglierà a questo::329 330 pub ed25519 2022-12-20 [SC] [expires: 2022-12-19]331 000000000000000000000000AAAABBBBCCCCDDDD332 Keygrip = 1111000000000000000000000000000000000000333 uid [ultimate] Alice Dev <adev@kernel.org>334 sub cv25519 2022-12-20 [E] [expires: 2022-12-19]335 Keygrip = 2222000000000000000000000000000000000000336 sub ed25519 2022-12-20 [S]337 Keygrip = 3333000000000000000000000000000000000000338 339Trovate la voce keygrid che si trova sotto alla riga ``pub`` (appena sotto340all'impronta digitale della chiave primaria). Questo corrisponderà direttamente341ad un file nella cartella ``~/.gnupg``::342 343 $ cd ~/.gnupg/private-keys-v1.d344 $ ls345 1111000000000000000000000000000000000000.key346 2222000000000000000000000000000000000000.key347 3333000000000000000000000000000000000000.key348 349Quello che dovrete fare è rimuovere il file .key che corrisponde al keygrip350della chiave primaria::351 352 $ cd ~/.gnupg/private-keys-v1.d353 $ rm 1111000000000000000000000000000000000000.key354 355Ora, se eseguite il comando ``--list-secret-keys``, vedrete che la chiave356primaria non compare più (il simbolo ``#`` indica che non è disponibile)::357 358 $ gpg --list-secret-keys359 sec# ed25519 2022-12-20 [SC] [expires: 2024-12-19]360 000000000000000000000000AAAABBBBCCCCDDDD361 uid [ultimate] Alice Dev <adev@kernel.org>362 ssb cv25519 2022-12-20 [E] [expires: 2024-12-19]363 ssb ed25519 2022-12-20 [S]364 365Dovreste rimuovere anche i file ``secring.gpg`` che si trovano nella cartella366``~/.gnupg``, in quanto rimasugli delle versioni precedenti di GnuPG.367 368Se non avete la cartella "private-keys-v1.d"369~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~370 371Se non avete la cartella ``~/.gnupg/private-keys-v1.d``, allora le vostre372chiavi segrete sono ancora salvate nel vecchio file ``secring.gpg`` usato373da GnuPG v1. Effettuare una qualsiasi modifica alla vostra chiave, come374cambiare la passphare o aggiungere una sottochiave, dovrebbe convertire375automaticamente il vecchio formato ``secring.gpg``nel nuovo376``private-keys-v1.d``.377 378Una volta che l'avete fatto, assicuratevi di rimuovere il file ``secring.gpg``,379che continua a contenere la vostra chiave privata.380 381.. _it_smartcards:382 383Spostare le sottochiavi in un apposito dispositivo criptato384===========================================================385 386Nonostante la chiave primaria sia ora al riparo da occhi e mani indiscrete,387le sottochiavi si trovano ancora nella vostra cartella home. Chiunque riesca388a mettere le sue mani su quelle chiavi riuscirà a decriptare le vostre389comunicazioni o a falsificare le vostre firme (se conoscono la passphrase).390Inoltre, ogni volta che viene fatta un'operazione con GnuPG, le chiavi vengono391caricate nella memoria di sistema e potrebbero essere rubate con l'uso di392malware sofisticati (pensate a Meltdown e a Spectre).393 394Il miglior modo per proteggere le proprie chiave è di spostarle su un395dispositivo specializzato in grado di effettuare operazioni smartcard.396 397I benefici di una smartcard398---------------------------399 400Una smartcard contiene un chip crittografico che è capace di immagazzinare401le chiavi private ed effettuare operazioni crittografiche direttamente sulla402carta stessa. Dato che la chiave non lascia mai la smartcard, il sistema403operativo usato sul computer non sarà in grado di accedere alle chiavi.404Questo è molto diverso dai dischi USB criptati che abbiamo usato allo scopo di405avere una copia di riserva sicura -- quando il dispositivo USB è connesso e406montato, il sistema operativo potrà accedere al contenuto delle chiavi private.407 408L'uso di un disco USB criptato non può sostituire le funzioni di un dispositivo409capace di operazioni di tipo smartcard.410 411Dispositivi smartcard disponibili412---------------------------------413 414A meno che tutti i vostri computer dispongano di lettori smartcard, il modo415più semplice è equipaggiarsi di un dispositivo USB specializzato che416implementi le funzionalità delle smartcard. Sul mercato ci sono diverse417soluzioni disponibili:418 419- `Nitrokey Start`_: è Open hardware e Free Software, è basata sul progetto420 `GnuK`_ della FSIJ. Questo è uno dei pochi dispositivi a supportare le chiavi421 ECC ED25519, ma offre meno funzionalità di sicurezza (come la resistenza422 alla manomissione o alcuni attacchi ad un canale laterale).423- `Nitrokey Pro 2`_: è simile alla Nitrokey Start, ma è più resistente alla424 manomissione e offre più funzionalità di sicurezza. La Pro 2 supporta la425 crittografia ECC (NISTP).426- `Yubikey 5`_: l'hardware e il software sono proprietari, ma è più economica427 della Nitrokey Pro ed è venduta anche con porta USB-C il che è utile con i428 computer portatili più recenti. In aggiunta, offre altre funzionalità di429 sicurezza come FIDO, U2F, e ora supporta anche le chiavi ECC (NISTP)430 431La vostra scelta dipenderà dal costo, la disponibilità nella vostra regione, e432sulla scelta fra dispositivi aperti e proprietari.433 434.. note::435 436 Se siete nella lista MAINTAINERS o avete un profilo su kernel.org, allora437 `potrete avere gratuitamente una Nitrokey Start`_ grazie alla fondazione438 Linux.439 440.. _`Nitrokey Start`: https://shop.nitrokey.com/shop/product/nitrokey-start-6441.. _`Nitrokey Pro 2`: https://shop.nitrokey.com/shop/product/nitrokey-pro-2-3442.. _`Yubikey 5`: https://www.yubico.com/product/yubikey-5-overview/443.. _Gnuk: https://www.fsij.org/doc-gnuk/444.. _`potrete avere gratuitamente una Nitrokey Start`: https://www.kernel.org/nitrokey-digital-tokens-for-kernel-developers.html445 446Configurare il vostro dispositivo smartcard447-------------------------------------------448 449Il vostro dispositivo smartcard dovrebbe iniziare a funzionare non appena450lo collegate ad un qualsiasi computer Linux moderno. Potete verificarlo451eseguendo::452 453 $ gpg --card-status454 455Se vedete tutti i dettagli della smartcard, allora ci siamo. Sfortunatamente,456affrontare tutti i possibili motivi per cui le cose potrebbero non funzionare457non è lo scopo di questa guida. Se avete problemi nel far funzionare la carta458con GnuPG, cercate aiuto attraverso i soliti canali di supporto.459 460Per configurare la vostra smartcard, dato che non c'è una via facile dalla461riga di comando, dovrete usate il menu di GnuPG::462 463 $ gpg --card-edit464 [...omitted...]465 gpg/card> admin466 Admin commands are allowed467 gpg/card> passwd468 469Dovreste impostare il PIN dell'utente (1), quello dell'amministratore (3) e il470codice di reset (4). Assicuratevi di annotare e salvare questi codici in un471posto sicuro -- specialmente il PIN dell'amministratore e il codice di reset472(che vi permetterà di azzerare completamente la smartcard). Il PIN473dell'amministratore viene usato così raramente che è inevitabile dimenticarselo474se non lo si annota.475 476Tornando al nostro menu, potete impostare anche altri valori (come il nome,477il sesso, informazioni d'accesso, eccetera), ma non sono necessari e aggiunge478altre informazioni sulla carta che potrebbero trapelare in caso di smarrimento.479 480.. note::481 482 A dispetto del nome "PIN", né il PIN utente né quello dell'amministratore483 devono essere esclusivamente numerici.484 485.. warning::486 487 Alcuni dispositivi richiedono la presenza delle sottochiavi nel dispositivo488 stesso prima che possiate cambiare la passphare. Verificate la489 documentazione del produttore.490 491Spostare le sottochiavi sulla smartcard492---------------------------------------493 494Uscite dal menu (usando "q") e salverete tutte le modifiche. Poi, spostiamo495tutte le sottochiavi sulla smartcard. Per la maggior parte delle operazioni496vi serviranno sia la passphrase della chiave PGP che il PIN497dell'amministratore::498 499 $ gpg --edit-key [fpr]500 501 Secret subkeys are available.502 503 pub ed25519/AAAABBBBCCCCDDDD504 created: 2022-12-20 expires: 2024-12-19 usage: SC505 trust: ultimate validity: ultimate506 ssb cv25519/1111222233334444507 created: 2022-12-20 expires: never usage: E508 ssb ed25519/5555666677778888509 created: 2017-12-07 expires: never usage: S510 [ultimate] (1). Alice Dev <adev@kernel.org>511 512 gpg>513 514Usando ``--edit-key`` si tornerà alla modalità menu e noterete che515la lista delle chiavi è leggermente diversa. Da questo momento in poi,516tutti i comandi saranno eseguiti nella modalità menu, come indicato517da ``gpg>``.518 519Per prima cosa, selezioniamo la chiave che verrà messa sulla carta --520potete farlo digitando ``key 1`` (è la prima della lista, la sottochiave521**[E]**)::522 523 gpg> key 1524 525Nel'output dovreste vedere ``ssb*`` associato alla chiave **[E]**. Il simbolo526``*`` indica che la chiave è stata "selezionata". Funziona come un527interruttore, ovvero se scrivete nuovamente ``key 1``, il simbolo ``*`` sparirà528e la chiave non sarà più selezionata.529 530Ora, spostiamo la chiave sulla smartcard::531 532 gpg> keytocard533 Please select where to store the key:534 (2) Encryption key535 Your selection? 2536 537Dato che è la nostra chiave **[E]**, ha senso metterla nella sezione criptata.538Quando confermerete la selezione, vi verrà chiesta la passphrase della vostra539chiave PGP, e poi il PIN dell'amministratore. Se il comando ritorna senza540errori, allora la vostra chiave è stata spostata con successo.541 542**Importante**: digitate nuovamente ``key 1`` per deselezionare la prima chiave543e selezionate la seconda chiave **[S]** con ``key 2``::544 545 gpg> key 1546 gpg> key 2547 gpg> keytocard548 Please select where to store the key:549 (1) Signature key550 (3) Authentication key551 Your selection? 1552 553Potete usare la chiave **[S]** sia per firmare che per autenticare, ma vogliamo554che sia nella sezione di firma, quindi scegliete (1). Ancora una volta, se il555comando ritorna senza errori, allora l'operazione è avvenuta con successo::556 557 gpg> q558 Save changes? (y/N) y559 560Salvando le modifiche cancellerete dalla vostra cartella home tutte le chiavi561che avete spostato sulla carta (ma questo non è un problema, perché abbiamo562fatto delle copie di sicurezza nel caso in cui dovessimo configurare una563nuova smartcard).564 565Verificare che le chiavi siano state spostate566~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~567 568Ora, se doveste usare l'opzione ``--list-secret-keys``, vedrete una569sottile differenza nell'output::570 571 $ gpg --list-secret-keys572 sec# ed25519 2022-12-20 [SC] [expires: 2024-12-19]573 000000000000000000000000AAAABBBBCCCCDDDD574 uid [ultimate] Alice Dev <adev@kernel.org>575 ssb> cv25519 2022-12-20 [E] [expires: 2024-12-19]576 ssb> ed25519 2022-12-20 [S]577 578Il simbolo ``>`` in ``ssb>`` indica che la sottochiave è disponibile solo579nella smartcard. Se tornate nella vostra cartella delle chiavi segrete e580guardate al suo contenuto, noterete che i file ``.key`` sono stati sostituiti581con degli stub::582 583 $ cd ~/.gnupg/private-keys-v1.d584 $ strings *.key | grep 'private-key'585 586Per indicare che i file sono solo degli stub e che in realtà il contenuto è587sulla smartcard, l'output dovrebbe mostrarvi ``shadowed-private-key``.588 589Verificare che la smartcard funzioni590~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~591 592Per verificare che la smartcard funzioni come dovuto, potete creare593una firma::594 595 $ echo "Hello world" | gpg --clearsign > /tmp/test.asc596 $ gpg --verify /tmp/test.asc597 598Col primo comando dovrebbe chiedervi il PIN della smartcard, e poi dovrebbe599mostrare "Good signature" dopo l'esecuzione di ``gpg --verify``.600 601Complimenti, siete riusciti a rendere estremamente difficile il furto della602vostra identità digitale di sviluppatore.603 604Altre operazioni possibili con GnuPG605------------------------------------606 607Segue un breve accenno ad alcune delle operazioni più comuni che dovrete608fare con le vostre chiavi PGP.609 610Montare il disco con la chiave primaria611~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~612 613Vi servirà la vostra chiave principale per tutte le operazioni che seguiranno,614per cui per prima cosa dovrete accedere ai vostri backup e dire a GnuPG di615usarli::616 617 $ export GNUPGHOME=/media/disk/foo/gnupg-backup618 $ gpg --list-secret-keys619 620Dovete assicurarvi di vedere ``sec`` e non ``sec#`` nell'output del programma621(il simbolo ``#`` significa che la chiave non è disponibile e che state ancora622utilizzando la vostra solita cartella di lavoro).623 624Estendere la data di scadenza di una chiave625~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~626 627La chiave principale ha una data di scadenza di 2 anni dal momento della sua628creazione. Questo per motivi di sicurezza e per rendere obsolete le chiavi629che, eventualmente, dovessero sparire dai keyserver.630 631Per estendere di un anno, dalla data odierna, la scadenza di una vostra chiave,632eseguite::633 634 $ gpg --quick-set-expire [fpr] 1y635 636Se per voi è più facile da memorizzare, potete anche utilizzare una data637specifica (per esempio, il vostro compleanno o capodanno)::638 639 $ gpg --quick-set-expire [fpr] 2025-07-01640 641Ricordatevi di inviare l'aggiornamento ai keyserver::642 643 $ gpg --send-key [fpr]644 645Aggiornare la vostra cartella di lavoro dopo ogni modifica646~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~647 648Dopo aver fatto delle modifiche alle vostre chiavi usando uno spazio a parte,649dovreste importarle nella vostra cartella di lavoro abituale::650 651 $ gpg --export | gpg --homedir ~/.gnupg --import652 $ unset GNUPGHOME653 654Usare gpg-agent con ssh655~~~~~~~~~~~~~~~~~~~~~~~656 657Se dovete firmare tag o commit su un sistema remoto, potete ridirezionare il658vostro gpg-agent attraverso ssh. Consultate le istruzioni disponibili nella wiki659GnuPG:660 661- `Agent Forwarding over SSH`_662 663Funziona senza troppi intoppi se avete la possibilità di modificare le664impostazioni di sshd sul sistema remoto.665 666.. _`Agent Forwarding over SSH`: https://wiki.gnupg.org/AgentForwarding667 668.. _it_pgp_with_git:669 670Usare PGP con Git671=================672 673Una delle caratteristiche fondanti di Git è la sua natura decentralizzata --674una volta che il repositorio è stato clonato sul vostro sistema, avete la675storia completa del progetto, inclusi i suoi tag, i commit ed i rami. Tuttavia,676con i centinaia di repositori clonati che ci sono in giro, come si fa a677verificare che la loro copia di linux.git non è stata manomessa da qualcuno?678 679Oppure, cosa succede se viene scoperta una backdoor nel codice e la riga680"Autore" dice che sei stato tu, mentre tu sei abbastanza sicuro di681`non averci niente a che fare`_?682 683Per risolvere entrambi i problemi, Git ha introdotto l'integrazione con PGP.684I tag firmati dimostrano che il repositorio è integro assicurando che il suo685contenuto è lo stesso che si trova sulle macchine degli sviluppatori che hanno686creato il tag; mentre i commit firmati rendono praticamente impossibile687ad un malintenzionato di impersonarvi senza avere accesso alle vostre chiavi688PGP.689 690.. _`non averci niente a che fare`: https://github.com/jayphelps/git-blame-someone-else691 692Configurare git per usare la vostra chiave PGP693----------------------------------------------694 695Se avete solo una chiave segreta nel vostro portachiavi, allora non avete nulla696da fare in più dato che sarà la vostra chiave di base. Tuttavia, se doveste697avere più chiavi segrete, potete dire a git quale dovrebbe usare (``[fpg]``698è la vostra impronta digitale)::699 700 $ git config --global user.signingKey [fpr]701 702Come firmare i tag703------------------704 705Per creare un tag firmato, passate l'opzione ``-s`` al comando tag::706 707 $ git tag -s [tagname]708 709La nostra raccomandazione è quella di firmare sempre i tag git, perché710questo permette agli altri sviluppatori di verificare che il repositorio711git dal quale stanno prendendo il codice non è stato alterato intenzionalmente.712 713Come verificare i tag firmati714~~~~~~~~~~~~~~~~~~~~~~~~~~~~~715 716Per verificare un tag firmato, potete usare il comando ``verify-tag``::717 718 $ git verify-tag [tagname]719 720Se state prendendo un tag da un fork del repositorio del progetto, git721dovrebbe verificare automaticamente la firma di quello che state prendendo722e vi mostrerà il risultato durante l'operazione di merge::723 724 $ git pull [url] tags/sometag725 726Il merge conterrà qualcosa di simile::727 728 Merge tag 'sometag' of [url]729 730 [Tag message]731 732 # gpg: Signature made [...]733 # gpg: Good signature from [...]734 735Se state verificando il tag di qualcun altro, allora dovrete importare736la loro chiave PGP. Fate riferimento alla sezione ":ref:`it_verify_identities`"737che troverete più avanti.738 739Configurare git per firmare sempre i tag con annotazione740~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~741 742Se state creando un tag con annotazione è molto probabile che vogliate743firmarlo. Per imporre a git di firmare sempre un tag con annotazione,744dovete impostare la seguente opzione globale::745 746 $ git config --global tag.forceSignAnnotated true747 748Come usare commit firmati749-------------------------750 751Creare dei commit firmati è facile, ma è molto più difficile utilizzarli752nello sviluppo del kernel linux per via del fatto che ci si affida alle753liste di discussione e questo modo di procedere non mantiene le firme PGP754nei commit. In aggiunta, quando si usa *rebase* nel proprio repositorio755locale per allinearsi al kernel anche le proprie firme PGP verranno scartate.756Per questo motivo, la maggior parte degli sviluppatori del kernel non si757preoccupano troppo di firmare i propri commit ed ignoreranno quelli firmati758che si trovano in altri repositori usati per il proprio lavoro.759 760Tuttavia, se avete il vostro repositorio di lavoro disponibile al pubblico761su un qualche servizio di hosting git (kernel.org, infradead.org, ozlabs.org,762o altri), allora la raccomandazione è di firmare tutti i vostri commit763anche se gli sviluppatori non ne beneficeranno direttamente.764 765Vi raccomandiamo di farlo per i seguenti motivi:766 7671. Se dovesse mai esserci la necessità di fare delle analisi forensi o768 tracciare la provenienza di un codice, anche sorgenti mantenuti769 esternamente che hanno firme PGP sui commit avranno un certo valore a770 questo scopo.7712. Se dovesse mai capitarvi di clonare il vostro repositorio locale (per772 esempio dopo un danneggiamento del disco), la firma vi permetterà di773 verificare l'integrità del repositorio prima di riprendere il lavoro.7743. Se qualcuno volesse usare *cherry-pick* sui vostri commit, allora la firma775 permetterà di verificare l'integrità dei commit prima di applicarli.776 777Creare commit firmati778~~~~~~~~~~~~~~~~~~~~~779 780Per creare un commit firmato, dovete solamente aggiungere l'opzione ``-S``781al comando ``git commit`` (si usa la lettera maiuscola per evitare782conflitti con un'altra opzione)::783 784 $ git commit -S785 786Configurare git per firmare sempre i commit787~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~788 789Potete dire a git di firmare sempre i commit::790 791 git config --global commit.gpgSign true792 793.. note::794 795 Assicuratevi di aver configurato ``gpg-agent`` prima di abilitare796 questa opzione.797 798.. _it_verify_identities:799 800Come lavorare con patch firmate801-------------------------------802 803Esiste la possibilità di usare la vostra chiave PGP per firmare le patch che804invierete alla liste di discussione del kernel. I meccanismi esistenti per la805firma delle email (PGP-Mime o PGP-inline) tendono a causare problemi806nell'attività di revisione del codice. Si suggerisce, invece, di utilizare lo807strumento sviluppato da kernel.org che mette nell'intestazione del messaggio808un'attestazione delle firme crittografiche (tipo DKIM):809 810- `Patatt Patch Attestation`_811 812.. _`Patatt Patch Attestation`: https://pypi.org/project/patatt/813 814Installare e configurate patatt815~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~816 817Lo strumento patatt è disponibile per diverse distribuzioni, dunque cercatelo818prima lì. Oppure potete installarlo usano pypi "``pip install patatt``"819 820Se avete già configurato git con la vostra chiave PGP (usando821``user.signingKey``), allora patatt non ha bisogno di alcuna configurazione822aggiuntiva. Potete iniziare a firmare le vostre patch aggiungendo un aggancio a823git-send-email nel vostro repositorio::824 825 patatt install-hook826 827Ora, qualsiasi patch che invierete con ``git send-email`` verrà automaticamente828firmata usando la vostra firma crittografica.829 830Verificare le firme di patatt831~~~~~~~~~~~~~~~~~~~~~~~~~~~~~832 833Se usate ``b4`` per verificare ed applicare le patch, allora tenterà834automaticamente di verificare tutte le firme DKIM e patatt disponibili. Per835esempio::836 837 $ b4 am 20220720205013.890942-1-broonie@kernel.org838 [...]839 Checking attestation on all messages, may take a moment...840 ---841 ✓ [PATCH v1 1/3] kselftest/arm64: Correct buffer allocation for SVE Z registers842 ✓ [PATCH v1 2/3] arm64/sve: Document our actual ABI for clearing registers on syscall843 ✓ [PATCH v1 3/3] kselftest/arm64: Enforce actual ABI for SVE syscalls844 ---845 ✓ Signed: openpgp/broonie@kernel.org846 ✓ Signed: DKIM/kernel.org847 848.. note::849 850 Lo sviluppo di patatt e b4 è piuttosto attivo. Si consiglia di verificare la851 documentazione più recente.852 853.. _it_kernel_identities:854 855Come verificare l'identità degli sviluppatori del kernel856========================================================857 858Firmare i tag e i commit è facile, ma come si fa a verificare che la chiave859usata per firmare qualcosa appartenga davvero allo sviluppatore e non ad un860impostore?861 862Configurare l'auto-key-retrieval usando WKD e DANE863--------------------------------------------------864 865Se non siete ancora in possesso di una vasta collezione di chiavi pubbliche866di altri sviluppatori, allora potreste iniziare il vostro portachiavi867affidandovi ai servizi di auto-scoperta e auto-recupero. GnuPG può affidarsi868ad altre tecnologie di delega della fiducia, come DNSSEC e TLS, per sostenervi869nel caso in cui iniziare una propria rete di fiducia da zero sia troppo870scoraggiante.871 872Aggiungete il seguente testo al vostro file ``~/.gnupg/gpg.conf``::873 874 auto-key-locate wkd,dane,local875 auto-key-retrieve876 877La *DNS-Based Authentication of Named Entities* ("DANE") è un metodo878per la pubblicazione di chiavi pubbliche su DNS e per renderle sicure usando879zone firmate con DNSSEC. Il *Web Key Directory* ("WKD") è un metodo880alternativo che usa https a scopo di ricerca. Quando si usano DANE o WKD881per la ricerca di chiavi pubbliche, GnuPG validerà i certificati DNSSEC o TLS882prima di aggiungere al vostro portachiavi locale le eventuali chiavi trovate.883 884Kernel.org pubblica la WKD per tutti gli sviluppatori che hanno un account885kernel.org. Una volta che avete applicato le modifiche al file ``gpg.conf``,886potrete auto-recuperare le chiavi di Linus Torvalds e Greg Kroah-Hartman887(se non le avete già)::888 889 $ gpg --locate-keys torvalds@kernel.org gregkh@kernel.org890 891Se avete un account kernel.org, al fine di rendere più utile l'uso di WKD892da parte di altri sviluppatori del kernel, dovreste `aggiungere alla vostra893chiave lo UID di kernel.org`_.894 895.. _`aggiungere alla vostra chiave lo UID di kernel.org`: https://korg.wiki.kernel.org/userdoc/mail#adding_a_kernelorg_uid_to_your_pgp_key896 897Web of Trust (WOT) o Trust on First Use (TOFU)898----------------------------------------------899 900PGP incorpora un meccanismo di delega della fiducia conosciuto come901"Web of Trust". Di base, questo è un tentativo di sostituire la necessità902di un'autorità certificativa centralizzata tipica del mondo HTTPS/TLS.903Invece di avere svariati produttori software che decidono chi dovrebbero904essere le entità di certificazione di cui dovreste fidarvi, PGP lascia905la responsabilità ad ogni singolo utente.906 907Sfortunatamente, solo poche persone capiscono come funziona la rete di fiducia.908Nonostante sia un importante aspetto della specifica OpenPGP, recentemente909le versioni di GnuPG (2.2 e successive) hanno implementato un meccanisco910alternativo chiamato "Trust on First Use" (TOFU). Potete pensare a TOFU come911"ad un approccio all fidicia simile ad SSH". In SSH, la prima volta che vi912connettete ad un sistema remoto, l'impronta digitale della chiave viene913registrata e ricordata. Se la chiave dovesse cambiare in futuro, il programma914SSH vi avviserà e si rifiuterà di connettersi, obbligandovi a prendere una915decisione circa la fiducia che riponete nella nuova chiave. In modo simile,916la prima volta che importate la chiave PGP di qualcuno, si assume sia valida.917Se ad un certo punto GnuPG trova un'altra chiave con la stessa identità,918entrambe, la vecchia e la nuova, verranno segnate come invalide e dovrete919verificare manualmente quale tenere.920 921Vi raccomandiamo di usare il meccanisco TOFU+PGP (che è la nuova configurazione922di base di GnuPG v2). Per farlo, aggiungete (o modificate) l'impostazione923``trust-model`` in ``~/.gnupg/gpg.conf``::924 925 trust-model tofu+pgp926 927Usare il repositorio kernel.org per il web of trust928---------------------------------------------------929 930Il progetto kernel.org mantiene un repositorio git con le chiavi pubbliche degli sviluppatori in alternativa alla replica dei server di chiavi che negli ultimi anni sono spariti. La documentazione completa su come impostare il repositorio come vostra sorgente di chiavi pubbliche può essere trovato qui:931 932- `Kernel developer PGP Keyring`_933 934Se siete uno sviluppatore del kernel, per favore valutate l'idea di inviare la935vostra chiave per l'inclusione in quel portachiavi.936 937 938If you are a kernel developer, please consider submitting your key for939inclusion into that keyring.940 941.. _`Kernel developer PGP Keyring`: https://korg.docs.kernel.org/pgpkeys.html942