Le chiavi SSH con­sen­to­no di accedere ai re­po­si­to­ry di Git senza password. Per au­ten­ti­ca­re il di­spo­si­ti­vo dello svi­lup­pa­to­re o della svi­lup­pa­tri­ce si ricorre a una chiave SSH invece del classico nome utente e password.

Novità: offerta VPS
Il tuo server virtuale a prezzi im­bat­ti­bi­li

Prova il nostro VPS. I primi 30 giorni sono in omaggio e se allo scadere del periodo di prova non sarai convinto, ti rim­bor­se­re­mo tutte le spese sostenute.

Cos’è una chiave SSH?

Secure Shell (SSH) è un pro­to­col­lo standard che consente l’accesso criptato a sistemi remoti, con­sen­ten­do a un pro­gram­ma­to­re o a una pro­gram­ma­tri­ce di accedere al server dal proprio di­spo­si­ti­vo locale. In Git, SSH funge da pro­to­col­lo di tra­smis­sio­ne e consente a chi legge e a chi scrive di accedere ai re­po­si­to­ry remoti.

Per con­sen­ti­re l’au­ten­ti­ca­zio­ne del di­spo­si­ti­vo e as­si­cu­ra­re la sicurezza dei dati trasmessi si usa una con­nes­sio­ne criptata. Se così non fosse, qualsiasi persona esterna potrebbe mo­di­fi­ca­re i re­po­si­to­ry a proprio pia­ci­men­to.

Per la creazione di chiavi SSH, Git usa il metodo della crit­to­gra­fia asim­me­tri­ca, 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 re­po­si­to­ry GitHub rende superfluo l’in­se­ri­men­to di una password. In generale, l’accesso senza password è con­si­de­ra­to più sicuro poiché impedisce gli attacchi di keylogger o trojan, che agiscono proprio sulla chiave di accesso. Invece di con­fer­ma­re l’identità di una persona mediante una password, il pro­ce­di­men­to mira ad au­ten­ti­ca­re la macchina sulla quale è salvata la chiave privata.

Usare Git mediante pro­to­col­lo SSH è de­ci­sa­men­te pratico. Una volta messa a punto la con­fi­gu­ra­zio­ne della chiave SSH, sarà possibile accedere di­ret­ta­men­te a GitHub senza dover fare nient’altro. Anche altri pro­to­col­li e servizi si servono di chiavi SSH per stabilire con­nes­sio­ni di rete criptate. Oltre a SSH, Git consente l’uso del pro­to­col­lo sicuro SFTP per lo scambio di dati, senza necessità di con­fi­gu­ra­re ul­te­rior­men­te il programma.

La con­nes­sio­ne con i re­po­si­to­ry di Git avviene nor­mal­men­te dalla riga di comando. Se è stata impostata una chiave SSH, è possibile eseguire fa­cil­men­te git push sul proprio re­po­si­to­ry:

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

Oltre alle ap­pli­ca­zio­ni a riga di comando, anche quelle con in­ter­fac­cia grafica possono usare le chiavi SSH a proprio vantaggio. Ad esempio, i moderni programmi FTP sup­por­ta­no l’SSH File Transfer Protocol (SFTP). Questo pro­to­col­lo 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 è ne­ces­sa­rio salvare la chiave pubblica su GitHub, mentre la chiave privata resta sul computer. L’ap­pa­rec­chio in uso viene au­ten­ti­ca­to su GitHub mediante un confronto dei dati contenuti nella chiave. Ciò consente di accedere ai re­po­si­to­ry personali con un permesso di scrittura. Questo metodo funziona anche con i software al­ter­na­ti­vi 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 so­sti­tuir­si a voi, accedendo al server con la vostra identità e mo­di­fi­can­do il codice dei re­po­si­to­ry a vostro nome.

Requisiti per l’uso di una chiave SSH con GitHub

Per il nostro esempio partiamo dal pre­sup­po­sto che il pro­gram­ma­to­re o la pro­gram­ma­tri­ce lavori in un ambiente simile a Linux, ad esempio Linux/Unix, macOS o Windows con sot­to­si­ste­ma WSL2. Inoltre, è ne­ces­sa­rio:

  • Aver in­stal­la­to Git
  • Aver in­stal­la­to SSH
  • Aver creato un account GitHub

Anzitutto ve­ri­fi­ca­te che i requisiti a livello locale siano sod­di­sfat­ti. Con il seguente comando con­trol­la­te se Git e SSH sono in­stal­la­ti. 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
Immagine: Verifica dello stato di installazione di Git e SSH
Git e SSH risultano in­stal­la­ti sul sistema. Nel nostro esempio viene cercato un comando ine­si­sten­te “unknown”.

Suc­ces­si­va­men­te create la directory .ssh nella cartella utente, qualora questa non esista già:

mkdir -vp ~/.ssh/

Di seguito vi spie­ghia­mo come creare e re­gi­stra­re una chiave SSH da usare su GitHub. Dopo aver portato a termine questo passaggio vi mo­stre­re­mo come salvare la chiave SSH pubblica su GitHub e come accedere ai re­po­si­to­ry. Questi i passaggi in sintesi:

  1. Re­gi­stra­re il paio di chiavi SSH sul proprio di­spo­si­ti­vo
  2. Salvare la chiave SSH pubblica su GitHub
  3. Accedere ai re­po­si­to­ry GitHub tramite la chiave SSH

Creare e re­gi­stra­re la chiave SSH sul proprio di­spo­si­ti­vo

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 ese­gui­te­li nella riga di comando.

A tal proposito facciamo ri­fe­ri­men­to alla do­cu­men­ta­zio­ne ufficiale di GitHub. La procedura cambia pe­rio­di­ca­men­te, pertanto può essere utile farvi ri­fe­ri­men­to di tanto in tanto per cor­reg­ge­re 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, nor­mal­men­te di­spo­ni­bi­le sul sistema in quanto parte dell’in­stal­la­zio­ne OpenSSH.

Inserite ssh-keygen nella riga di comando e spe­ci­fi­ca­te 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 ne­ces­sa­ria­men­te essere lo stesso indirizzo e-mail che usate per accedere a GitHub.

Il comando ssh-keygen chiede di spe­ci­fi­ca­re una pas­sph­ra­se per la chiave privata. Al contrario di una password, una pas­sph­ra­se può contenere spazi. Inoltre, dovrebbe contenere più parole, in modo tale da risultare più facile da ricordare e più difficile da in­do­vi­na­re. Per aumentare il grado di sicurezza, è possibile inserire anche numeri o caratteri speciali. Inserite la pas­sph­ra­se e premete [Invio]. Ripetete il processo per portare a termine la creazione di una coppia di chiavi SSH.

Immagine: Generazione di un SSH-Keypair per GitHub
La creazione della chiave SSH da usare con GitHub è andata buon fine.
Consiglio

Per la nostra coppia di chiavi usiamo l’algoritmo Ed25519, uno dei numerosi di­spo­ni­bi­li. Nell’articolo dedicato ai processi crit­to­gra­fi­ci potete trovare in­for­ma­zio­ni più det­ta­glia­te su questo tema.

Prima di usare la nuova chiave SSH con GitHub, è possibile eseguire un ulteriore passaggio opzionale, ma for­te­men­te con­si­glia­to. Questo consiste nell’ag­giun­ge­re la chiave privata al co­sid­det­to “SSH Agent”. L’SSH Agent è un processo che viene eseguito in back­ground sul sistema locale. Copiate il seguente snippet di codice nella riga di comando e, quando vi viene richiesto, inserite la pas­sph­ra­se:

  • 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 con­nes­sio­ni senza dover inserire ogni volta la pas­sph­ra­se. 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 pas­sph­ra­se only needs to be supplied once. A con­nec­tion 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

Tra­du­zio­ne: “SSH Agent è un programma che salva le chiavi private di un utente, di modo che la pas­sph­ra­se debba essere inserita solo una volta. È possibile inoltrare una con­nes­sio­ne con l’SSH Agent con­net­ten­do­si a un server. In tal modo i comandi SSH sul server possono servirsi dell’SSH Agent attivato sul computer dell’utente.” (tra­du­zio­ne di IONOS)

Salvare la chiave SSH su GitHub

Ora che avete generato una coppia di chiavi sul vostro sistema locale, metà della co­mu­ni­ca­zio­ne crit­to­gra­fa­ta è pronta per l’uso su Git via SSH. Il passaggio suc­ces­si­vo consiste nel salvare la chiave SSH pubblica su GitHub.

Immagine: Pagina di configurazione dell’account GitHub
Ef­fet­tua­te l’accesso all’account GitHub e cliccate su “SSH and GPG Keys” al menu Settings (im­po­sta­zio­ni).
Immagine: Impostazioni GitHub per aggiungere una chiave SSH
Alla voce di menu “SSH keys” cliccate sul tasto “New SSH key” per aprire la pagina e ag­giun­ge­re una nuova chiave.

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.

At­ten­zio­ne: l’esten­sio­ne del file con­te­nen­te 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 esten­sio­ne. Con­di­vi­de­te la chiave pubblica solo con GitHub e mai con terzi.

Immagine: Contenuto della chiave pubblica nella riga di comando
Copiate la chiave pubblica generata e tornate alla pagina GitHub.
Immagine: Chiave SSH pubblica copiata nella pagina delle impostazioni di GitHub
Inserite la chiave pubblica copiata ed even­tual­men­te as­se­gna­te­le un titolo. Salvate le modifiche cliccando sul tasto “Add SSH key”.
Immagine: Riepilogo delle chiavi SSH aggiunte su GitHub
La nuova chiave SSH di GitHub verrà vi­sua­liz­za­ta nel riepilogo delle chiavi.

Accedere ai re­po­si­to­ry GitHub tramite chiave SSH

Ora che avete generato la chiave locale e salvato la chiave SSH pubblica su GitHub, ve­ri­fi­ca­te anzitutto se la con­nes­sio­ne funziona. Per farlo usate il seguente comando:

ssh -T git@github.com
Immagine: Test di connessione con GitHub via SSH andato a buon fine
La con­nes­sio­ne criptata con GitHub funziona.

Se è la prima volta che vi con­net­te­te a GitHub dal vostro di­spo­si­ti­vo, vi verrà chiesto di ag­giun­ge­re il server alla lista dei server co­no­sciu­ti o “Known Hosts”:

Immagine: Il server GitHub viene aggiunto alla lista dei “known host SSH”
Con­fer­ma­te l’aggiunta del server premendo “yes” e quindi “Invio”.

Per quanto riguarda l’accesso ai re­po­si­to­ry di GitHub, si distingue fra accesso in lettura e accesso in scrittura. I re­po­si­to­ry pubblici possono essere letti da chiunque. Per farlo non è ne­ces­sa­rio au­ten­ti­car­si, ovvero inserire una chiave SSH.

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

Immagine: Pagina di riepilogo del repository cURL
Riepilogo del codice contenuto nel re­po­si­to­ry cURL. / Fonte: https://github.com/curl/curl
Immagine: URL clone del repository cURL copiato
Copiate l’URL clone del re­po­si­to­ry cURL. / Fonte: https://github.com/curl/curl

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

cd ~/Desktop/
mkdir -p repo && cd repo
git clone https://github.com/curl/curl.git
Immagine: Il repository cURL viene clonato sulla riga di comando locale
Il re­po­si­to­ry cURL clonato è ora presente nella cartella curl.

Passate alla cartella di re­po­si­to­ry cURL e, con il comando git status, vi­sua­liz­za­te lo stato del re­po­si­to­ry:

cd ~/Desktop/repo/curl/
git status
Immagine: Stato del repository locale cURL
L’output di git status evidenzia che lo stato è ag­gior­na­to.

Anche per eseguire il comando git pull, che serve ad ag­gior­na­re un re­po­si­to­ry allo stato più recente, è suf­fi­cien­te disporre di un accesso in lettura. Ora eseguite git pull nella cartella del re­po­si­to­ry. Questa ope­ra­zio­ne dovrebbe fun­zio­na­re, anche se con molta pro­ba­bi­li­tà non saranno di­spo­ni­bi­li alcune modifiche:

git pull

Ora cercate di scrivere sul re­po­si­to­ry GitHub con il comando git push:

git push
Immagine: Risultato di git pull e git push sul repository locale cURL
Git pull funziona, invece git push non va a buon fine, perché il nostro di­spo­si­ti­vo non è au­ten­ti­ca­to.

Cos’è successo in questo caso? L’URL clone usato per clonare il re­po­si­to­ry pubblico cURL inizia con HTTPS. Pertanto, per il nostro clone locale è stato salvato un URL HTTPS come origin. Ora ve­ri­fi­ca­te l’origin con il comando git show.

git remote -v show
Immagine: URL remote del repository locale cURL sulla riga di comando
Vengono vi­sua­liz­za­ti tutti gli URL per le ope­ra­zio­ni git fetch e git push.

Per l’accesso in lettura è suf­fi­cien­te un URL HTTPS, ma per i premessi di accesso in scrittura sui re­po­si­to­ry GitHub è ne­ces­sa­ria una chiave SSH. Questo perché GitHub dal 2021 non supporta più l’au­ten­ti­ca­zio­ne degli utenti tramite nome utente e password.

Se volete comunque testare git push potete usare questo piccolo trucco: anzitutto create un re­po­si­to­ry vuoto a parte con GitHub:

Immagine: Creazione di un nuovo repository su GitHub
Create un nuovo re­po­si­to­ry con il nome “test”.
Immagine: Riepilogo di un repository GitHub vuoto
Il re­po­si­to­ry GitHub vuoto contiene istru­zio­ni per la com­pi­la­zio­ne con il codice.

Seguendo le istru­zio­ni su GitHub mo­di­fi­ca­te l’URL push del clone locale cURL, di modo che il re­po­si­to­ry GitHub vuoto venga usato come origin. Quindi passate al branch “main” ed eseguite git push. L’ope­ra­zio­ne va a buon fine e quindi è possibile accedere alla chiave SSH pre­ce­den­te­men­te spe­ci­fi­ca­ta per con­sen­ti­re l’au­ten­ti­ca­zio­ne su GitHub.

git remote set-url origin git@github.com:<user>/test.git</user>
git branch -M main
git push -u origin main
Immagine: Modifica dell’URL push e git push dal repository locale
Git push funziona dopo aver mo­di­fi­ca­to l’URL push.

Usare una chiave SSH per diversi account GitHub

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

Tec­ni­ca­men­te è possibile uti­liz­za­re 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 trat­te­re­mo in questa sede. In generale è più comodo lavorare con un file SSH config. La sua con­fi­gu­ra­zio­ne è un po’ più laboriosa, ma è suf­fi­cien­te eseguirla una sola volta. Di seguito un riepilogo delle cartelle e dei file inclusi nella con­fi­gu­ra­zio­ne SSH:

Con­fi­gu­ra­zio­ne SSH Percorso Spie­ga­zio­ne
Cartella Config ~/.ssh/ Contiene la con­fi­gu­ra­zio­ne 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 con­fi­gu­ra­zio­ne SSH.
Known hosts ~/.ssh/known_hosts Lista degli host connessi in pre­ce­den­za.

Ora create il file config SSH. Generate un file, mo­di­fi­ca­te i permessi utente e apritelo dall’editor della riga di comando:

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

Suc­ces­si­va­men­te copiate il seguente snippet di codice nell’editor e seguite le in­di­ca­zio­ni negli screen­shot per salvare il file:

# Github
Host github github.com
    HostName github.com
    User git
    IdentityFile "~/.ssh/github_id_ed25519"
    IdentitiesOnly yes
Immagine: Configurazione GitHub nel file SSH config
Ag­giun­ge­te il blocco di con­fi­gu­ra­zio­ne e premete Ctrl + X per scrivere le modifiche e chiudere l’editor.
Immagine: Scrittura del file SSH config modificato
Con­fer­ma­te il nome del file premendo Invio.
Immagine: Conferma delle modifiche al file SSH config
Con­fer­ma­te le modifiche scritte premendo Invio.

Dopo aver inserito il blocco di con­fi­gu­ra­zio­ne di GitHub, è possibile stabilire una con­nes­sio­ne SSH spe­ci­fi­can­do la sigla dell’host di github pre­ce­den­te­men­te definita:

ssh -T github

Inserite nello schema pre­sen­ta­to i seguenti blocchi di con­fi­gu­ra­zio­ne per ulteriori servizi o account nel file SSH config. Di seguito i parametri in uso:

Im­po­sta­zio­ne Spie­ga­zio­ne Esempio
Host Può contenere diversi nomi a piacere. github.com github
HostName Nome dell’host del sistema remoto su cui è in uso il pro­to­col­lo SSH; è possibile usare anche un indirizzo IP. github.com
User Utente Git sul sistema remoto; il nome deve cor­ri­spon­de­re esat­ta­men­te. git
Iden­ti­ty­Fi­le Percorso assoluto della chiave privata. Mo­di­fi­ca­te­lo qualora usiate più chiavi dif­fe­ren­ti. “~/.ssh/github_id_ed25519"
Iden­ti­tie­sOn­ly Sta­bi­li­sce che l’accesso per questo host deve avvenire solo mediante la chiave. yes

Infine, un ultimo consiglio. Qualora le con­fi­gu­ra­zio­ni SSH vengano definite per diversi host con chiavi proprie, in fondo al file dovrete ag­giun­ge­re uno snippet di codice con le im­po­sta­zio­ni 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 spe­ci­fi­ca­ti senza chiave SSH. Potete stabilire una con­nes­sio­ne a un host via comando SSH con il vostro nome utente e inserire la password quando la con­nes­sio­ne viene stabilita:

ssh user@host

In assenza della riga “Iden­ti­tie­sOn­ly no” nella con­fi­gu­ra­zio­ne finale, SSH prova una dopo l’altra tutte le chiavi salvate in ~./ssh/ per con­net­ter­si al server. Qualora non trovi la chiave cor­ri­spon­den­te, rimanderà l’errore “Too many au­then­ti­ca­tion failures”.

Vai al menu prin­ci­pa­le