Uso delle chiavi SSH con GitHub

Le chiavi SSH consentono di accedere ai repository di Git senza password. Per autenticare il dispositivo dello sviluppatore o della sviluppatrice si ricorre a una chiave SSH invece del classico nome utente e password.

Prova gratuita per VPS di IONOS

Prova subito un VPS gratis - Prova il tuo server virtuale per 30 giorni!

Risorse dedicate
Traffico illimitato
Consulente personale

Cos’è una chiave SSH?

Secure Shell (SSH) è un protocollo standard che consente l’accesso criptato a sistemi remoti, consentendo a un programmatore o a una programmatrice di accedere al server dal proprio dispositivo locale. In Git, SSH funge da protocollo di trasmissione e consente a chi legge e a chi scrive di accedere ai repository remoti.

Per consentire l’autenticazione del dispositivo e assicurare la sicurezza dei dati trasmessi si usa una connessione criptata. Se così non fosse, qualsiasi persona esterna potrebbe modificare i repository a proprio piacimento.

Per la creazione di chiavi SSH, Git usa il metodo della crittografia asimmetrica, che consiste nel creare una coppia di chiavi private e pubbliche, anche definita “Public-Private Keypair”. La chiave privata resta sul computer. La chiave pubblica viene invece condivisa con servizi di terze parti, ad esempio con GitHub.

L’uso di una chiave SSH per accedere ai repository GitHub rende superfluo l’inserimento di una password. In generale, l’accesso senza password è considerato più sicuro poiché impedisce gli attacchi di keylogger o trojan, che agiscono proprio sulla chiave di accesso. Invece di confermare l’identità di una persona mediante una password, il procedimento mira ad autenticare la macchina sulla quale è salvata la chiave privata.

Usare Git mediante protocollo SSH è decisamente pratico. Una volta messa a punto la configurazione della chiave SSH, sarà possibile accedere direttamente a GitHub senza dover fare nient’altro. Anche altri protocolli e servizi si servono di chiavi SSH per stabilire connessioni di rete criptate. Oltre a SSH, Git consente l’uso del protocollo sicuro SFTP per lo scambio di dati, senza necessità di configurare ulteriormente il programma.

La connessione con i repository di Git avviene normalmente dalla riga di comando. Se è stata impostata una chiave SSH, è possibile eseguire facilmente git push sul proprio repository:

cd ./folder-with-git-repo/
git push

Oltre alle applicazioni a riga di comando, anche quelle con interfaccia grafica possono usare le chiavi SSH a proprio vantaggio. Ad esempio, i moderni programmi FTP supportano l’SSH File Transfer Protocol (SFTP). Questo protocollo si basa su SSH e si serve delle chiavi SSH già esistenti.

Come usare le chiavi SSH con GitHub

Per poter accedere al proprio account GitHub tramite chiave SSH è necessario salvare la chiave pubblica su GitHub, mentre la chiave privata resta sul computer. L’apparecchio in uso viene autenticato su GitHub mediante un confronto dei dati contenuti nella chiave. Ciò consente di accedere ai repository personali con un permesso di scrittura. Questo metodo funziona anche con i software alternativi a GitHub, ad esempio Gitlab o Bitbucket.

Anche se le chiavi SSH sono uno strumento molto pratico, il loro uso richiede sempre la dovuta cautela. Non fornite mai, per nessuna ragione, la chiave privata a terzi. In caso contrario, chi è in possesso della chiave potrebbe sostituirsi a voi, accedendo al server con la vostra identità e modificando il codice dei repository a vostro nome.

Requisiti per l’uso di una chiave SSH con GitHub

Per il nostro esempio partiamo dal presupposto che il programmatore o la programmatrice lavori in un ambiente simile a Linux, ad esempio Linux/Unix, macOS o Windows con sottosistema WSL2. Inoltre, è necessario:

  • Aver installato Git
  • Aver installato SSH
  • Aver creato un account GitHub

Anzitutto verificate che i requisiti a livello locale siano soddisfatti. Con il seguente comando controllate se Git e SSH sono installati. Se non si ottengono le notifiche di errore “git not found” o “ssh not found”, significa che entrambi sono presenti sul sistema:

which git ssh

Successivamente create la directory .ssh nella cartella utente, qualora questa non esista già:

mkdir -vp ~/.ssh/

Di seguito vi spieghiamo come creare e registrare una chiave SSH da usare su GitHub. Dopo aver portato a termine questo passaggio vi mostreremo come salvare la chiave SSH pubblica su GitHub e come accedere ai repository. Questi i passaggi in sintesi:

  1. Registrare il paio di chiavi SSH sul proprio dispositivo
  2. Salvare la chiave SSH pubblica su GitHub
  3. Accedere ai repository GitHub tramite la chiave SSH

Creare e registrare la chiave SSH sul proprio dispositivo

Il primo passaggio consiste nel creare una coppia di chiavi pubbliche/private sul proprio sistema locale. Copiate i comandi nello stesso ordine in cui sono elencati ed eseguiteli nella riga di comando.

A tal proposito facciamo riferimento alla documentazione ufficiale di GitHub. La procedura cambia periodicamente, pertanto può essere utile farvi riferimento di tanto in tanto per correggere eventuali errori SSH.

Anzitutto, avviate lo strumento SSH-Key Generator per creare una coppia di chiavi pubbliche/private per GitHub. A tal proposito usate il comando ssh-keygen, normalmente disponibile sul sistema in quanto parte dell’installazione OpenSSH.

Inserite ssh-keygen nella riga di comando e specificate tre opzioni:

  • L’opzione -f seguita dal percorso e dal nome della nuova chiave
  • L’opzione -t seguita dal nome dell’algoritmo, in questo caso ed25519
  • L’opzione -C seguita da un indirizzo e-mail come commento
ssh-keygen -f "$HOME/.ssh/github_id_ed25519" -t ed25519 -C "your_email@example.com"
bash
N.B.

Per generare la coppia di chiavi potete usare l’indirizzo e-mail che preferite. Questo funge solo da etichetta e non deve necessariamente essere lo stesso indirizzo e-mail che usate per accedere a GitHub.

Il comando ssh-keygen chiede di specificare una passphrase per la chiave privata. Al contrario di una password, una passphrase può contenere spazi. Inoltre, dovrebbe contenere più parole, in modo tale da risultare più facile da ricordare e più difficile da indovinare. Per aumentare il grado di sicurezza, è possibile inserire anche numeri o caratteri speciali. Inserite la passphrase e premete [Invio]. Ripetete il processo per portare a termine la creazione di una coppia di chiavi SSH.

Consiglio

Per la nostra coppia di chiavi usiamo l’algoritmo Ed25519, uno dei numerosi disponibili. Nell’articolo dedicato ai processi crittografici potete trovare informazioni più dettagliate su questo tema.

Prima di usare la nuova chiave SSH con GitHub, è possibile eseguire un ulteriore passaggio opzionale, ma fortemente consigliato. Questo consiste nell’aggiungere la chiave privata al cosiddetto “SSH Agent”. L’SSH Agent è un processo che viene eseguito in background sul sistema locale. Copiate il seguente snippet di codice nella riga di comando e, quando vi viene richiesto, inserite la passphrase:

  • Windows / Linux
ssh-add ~/.ssh/github_id_ed25519
  • macOS fino a 11 Big Sur
ssh-add -K ~/.ssh/github_id_ed25519
  • macOS da 12 Monterey
ssh-add --apple-use-keychain ~/.ssh/github_id_ed25519

L’SSH Agent ha accesso alle chiavi private inserite e consente di usare queste connessioni senza dover inserire ogni volta la passphrase. Ma non serve solo a questo:

Citazione

“ssh agent is a program that can hold a user’s private key, so that the private key passphrase only needs to be supplied once. A connection to the agent can also be forwarded when logging into a server, allowing SSH commands on the server to use the agent running on the user’s desktop.” — Fonte: https://www.ssh.com/academy/ssh/keygen#adding-the-key-to-ssh-agent

Traduzione: “SSH Agent è un programma che salva le chiavi private di un utente, di modo che la passphrase debba essere inserita solo una volta. È possibile inoltrare una connessione con l’SSH Agent connettendosi a un server. In tal modo i comandi SSH sul server possono servirsi dell’SSH Agent attivato sul computer dell’utente.” (traduzione di IONOS)

Salvare la chiave SSH su GitHub

Ora che avete generato una coppia di chiavi sul vostro sistema locale, metà della comunicazione crittografata è pronta per l’uso su Git via SSH. Il passaggio successivo consiste nel salvare la chiave SSH pubblica su GitHub.

Ora avete bisogno del contenuto della chiave pubblica. Passate alla riga di comando locale e inserite il seguente codice:

cat ~/.ssh/github_id_ed25519.pub
N.B.

Attenzione: l’estensione del file contenente la chiave pubblica è .pub, che sta per “public key”. Tuttavia è bene notare che la chiave privata non termina con .priv o simili, ma non ha alcuna estensione. Condividete la chiave pubblica solo con GitHub e mai con terzi.

Accedere ai repository GitHub tramite chiave SSH

Ora che avete generato la chiave locale e salvato la chiave SSH pubblica su GitHub, verificate anzitutto se la connessione funziona. Per farlo usate il seguente comando:

ssh -T git@github.com

Se è la prima volta che vi connettete a GitHub dal vostro dispositivo, vi verrà chiesto di aggiungere il server alla lista dei server conosciuti o “Known Hosts”:

Per quanto riguarda l’accesso ai repository di GitHub, si distingue fra accesso in lettura e accesso in scrittura. I repository pubblici possono essere letti da chiunque. Per farlo non è necessario autenticarsi, ovvero inserire una chiave SSH.

Per scaricare un repository come copia locale, si usa il comando git clone. A tal proposito prendiamo come esempio il repository di cURL, noto strumento di rete. Visitate la pagina GitHub del repository cURL pubblico e copiate l’URL clone:

Ora che avete l’URL clone, tornate alla riga di comando locale. Create una cartella di repository di esempio sul desktop e apritela. Quindi clonate il repository cURL eseguendo git clone con l’URL clone:

cd ~/Desktop/
mkdir -p repo && cd repo
git clone https://github.com/curl/curl.git

Passate alla cartella di repository cURL e, con il comando git status, visualizzate lo stato del repository:

cd ~/Desktop/repo/curl/
git status

Anche per eseguire il comando git pull, che serve ad aggiornare un repository allo stato più recente, è sufficiente disporre di un accesso in lettura. Ora eseguite git pull nella cartella del repository. Questa operazione dovrebbe funzionare, anche se con molta probabilità non saranno disponibili alcune modifiche:

git pull

Ora cercate di scrivere sul repository GitHub con il comando git push:

git push

Cos’è successo in questo caso? L’URL clone usato per clonare il repository pubblico cURL inizia con HTTPS. Pertanto, per il nostro clone locale è stato salvato un URL HTTPS come origin. Ora verificate l’origin con il comando git show.

git remote -v show

Per l’accesso in lettura è sufficiente un URL HTTPS, ma per i premessi di accesso in scrittura sui repository GitHub è necessaria una chiave SSH. Questo perché GitHub dal 2021 non supporta più l’autenticazione degli utenti tramite nome utente e password.

Se volete comunque testare git push potete usare questo piccolo trucco: anzitutto create un repository vuoto a parte con GitHub:

Seguendo le istruzioni su GitHub modificate l’URL push del clone locale cURL, di modo che il repository GitHub vuoto venga usato come origin. Quindi passate al branch “main” ed eseguite git push. L’operazione va a buon fine e quindi è possibile accedere alla chiave SSH precedentemente specificata per consentire l’autenticazione su GitHub.

git remote set-url origin git@github.com:<user>/test.git</user>
git branch -M main
git push -u origin main

Usare una chiave SSH per diversi account GitHub

È possibile usare tranquillamente una sola chiave SSH per diversi account GitHub o per altri servizi. Ricordate: la chiave pubblica può essere condivisa senza alcun problema.

Tecnicamente è possibile utilizzare le proprie chiavi SSH per diversi servizi e siti. Per farlo esistono due metodi:

  1. Invocare il comando SSH con parametri
  2. Creare un file SSH config

I comandi SSH con parametri possono risultare molto lunghi, pertanto non li tratteremo in questa sede. In generale è più comodo lavorare con un file SSH config. La sua configurazione è un po’ più laboriosa, ma è sufficiente eseguirla una sola volta. Di seguito un riepilogo delle cartelle e dei file inclusi nella configurazione SSH:

Configurazione SSH Percorso Spiegazione
Cartella Config ~/.ssh/ Contiene la configurazione SSH e la coppia di chiavi.
Private Key ~/.ssh/key-name Chiave privata di una coppia di chiavi.
Public Key ~/.ssh/key-name.pub Chiave pubblica di una coppia di chiavi.
File Config ~/.ssh/config File di configurazione SSH.
Known hosts ~/.ssh/known_hosts Lista degli host connessi in precedenza.

Ora create il file config SSH. Generate un file, modificate i permessi utente e apritelo dall’editor della riga di comando:

touch ~/.ssh/config
chmod 600 ~/.ssh/config
nano ~/.ssh/config

Successivamente copiate il seguente snippet di codice nell’editor e seguite le indicazioni negli screenshot per salvare il file:

# Github
Host github github.com
    HostName github.com
    User git
    IdentityFile "~/.ssh/github_id_ed25519"
    IdentitiesOnly yes

Dopo aver inserito il blocco di configurazione di GitHub, è possibile stabilire una connessione SSH specificando la sigla dell’host di github precedentemente definita:

ssh -T github

Inserite nello schema presentato i seguenti blocchi di configurazione per ulteriori servizi o account nel file SSH config. Di seguito i parametri in uso:

Impostazione Spiegazione Esempio
Host Può contenere diversi nomi a piacere. github.com github
HostName Nome dell’host del sistema remoto su cui è in uso il protocollo SSH; è possibile usare anche un indirizzo IP. github.com
User Utente Git sul sistema remoto; il nome deve corrispondere esattamente. git
IdentityFile Percorso assoluto della chiave privata. Modificatelo qualora usiate più chiavi differenti. “~/.ssh/github_id_ed25519"
IdentitiesOnly Stabilisce che l’accesso per questo host deve avvenire solo mediante la chiave. yes

Infine, un ultimo consiglio. Qualora le configurazioni SSH vengano definite per diversi host con chiavi proprie, in fondo al file dovrete aggiungere uno snippet di codice con le impostazioni per gli host non elencati:

# For all hosts
Host *
IdentitiesOnly no
IgnoreUnknown UseKeychain, AddKeysToAgent
UseKeychain yes
AddKeysToAgent yes

Questo consente di accedere agli host non specificati senza chiave SSH. Potete stabilire una connessione a un host via comando SSH con il vostro nome utente e inserire la password quando la connessione viene stabilita:

ssh user@host

In assenza della riga “IdentitiesOnly no” nella configurazione finale, SSH prova una dopo l’altra tutte le chiavi salvate in ~./ssh/ per connettersi al server. Qualora non trovi la chiave corrispondente, rimanderà l’errore “Too many authentication failures”.

Per offrirti una migliore esperienza di navigazione online questo sito web usa dei cookie, propri e di terze parti. Continuando a navigare sul sito acconsenti all’utilizzo dei cookie. Scopri di più sull’uso dei cookie e sulla possibilità di modificarne le impostazioni o negare il consenso.