SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor

Come risolvere SSH: Permission denied (publickey)

L’errore Permission denied (publickey) può avere cinque cause. Leggi l’output di ssh -v per identificarla e correggila senza perdere l’accesso al server.

Che cosa significa realmente Permission denied (publickey)

Permission denied (publickey) significa che il client ha inviato una o più chiavi pubbliche e il server non ne ha accettata nessuna. La rete funziona e sshd è in esecuzione: il rifiuto avviene nell'ultima fase dell'autenticazione. Se la sessione si interrompe prima di questo punto, il problema è connection refused o connection timed out, una diagnosi diversa che richiede verifiche differenti. La correzione non si basa su supposizioni, perché ssh -v indica quale delle cinque cause è presente.

Le parole tra parentesi indicano i metodi che il server era disposto ad accettare. Permission denied (publickey) da solo significa che l'accesso con password è disabilitato su quel server, quindi non è possibile usare una password come alternativa. Permission denied (publickey,password) significa che le password erano disponibili, ma anche quei tentativi di autenticazione non sono riusciti.

Un solo messaggio copre cinque problemi distinti ed è volutamente generico. Se il server rispondesse "utente inesistente" o "questa chiave non è installata", fornirebbe informazioni utili a chi cerca account validi. Non iniziare quindi a sostituire chiavi e modificare file di configurazione. Esegui un comando, leggi tre righe dell'output e riduci le cinque possibili cause a una sola.

Esegui prima ssh -v e leggi tre righe

Ripeti il comando che ha restituito l'errore, aggiungendo -v:

ssh -v deploy@203.0.113.10

Un'esecuzione ridotta ma realistica è simile alla seguente:

OpenSSH_9.6p1 Ubuntu-3ubuntu13, OpenSSL 3.0.13 30 Jan 2024
debug1: Connecting to 203.0.113.10 [203.0.113.10] port 22.
debug1: Connection established.
debug1: Authenticating to 203.0.113.10:22 as 'deploy'
debug1: Authentications that can continue: publickey
debug1: Next authentication method: publickey
debug1: Will attempt key: /home/you/.ssh/id_ed25519 ED25519 SHA256:0eL/8sBw... agent
debug1: Offering public key: /home/you/.ssh/id_ed25519 ED25519 SHA256:0eL/8sBw... agent
debug1: Authentications that can continue: publickey
debug1: No more authentication methods to try.
deploy@203.0.113.10: Permission denied (publickey).

Tre righe contengono tutte le informazioni necessarie.

Authenticating to 203.0.113.10:22 as 'deploy' è il nome utente effettivamente utilizzato. Non quello che intendevi usare, ma quello ricavato da ssh dalla riga di comando, da ~/.ssh/config o dal nome dell'utente locale.

Authentications that can continue: publickey è l'elenco dei metodi accettati dal server, inviato prima del tentativo con qualsiasi chiave. Se publickey manca da questo primo elenco, il server ha disabilitato l'accesso con chiave pubblica, quindi nessuna chiave potrà funzionare.

Offering public key: ... viene visualizzato per ogni chiave di cui ssh possiede già la parte pubblica, subito prima che offra quella chiave, seguito dal tipo di chiave e dalla relativa impronta SHA256. Una chiave letta da un file riporta il nome del file. Una chiave presente soltanto in ssh-agent mostra il commento memorizzato dall'agent invece del percorso; la parola agent alla fine della riga indica che la chiave è stata fornita dall'agent. ssh stampa questa riga subito prima di verificare che entrambe le estremità condividano un algoritmo di firma per la chiave. Pertanto, se la riga successiva è send_pubkey_test: no mutual signature algorithm, quella chiave non è stata effettivamente inviata (il caso è trattato dalla causa 5). Una chiave di cui ssh non è riuscito a leggere in anticipo la parte pubblica non produce mai una riga Offering: ssh registra Trying private key: ... indicando soltanto il nome del file, carica la chiave privata e invia immediatamente una richiesta firmata. Una chiave che non presenta nessuna delle due righe non è mai stata inviata al server.

Ora separa il problema in due casi:

  • Non è presente alcuna riga Offering public key o Trying private key per la chiave prevista. Il problema è sul computer locale, perché il server non ha mai ricevuto la chiave.
  • La chiave viene offerta e viene restituito di nuovo Authentications that can continue: publickey. Il server ha ricevuto la chiave ma l'ha rifiutata, quindi il problema è sul server.

Le cause riportate di seguito sono ordinate in base alla frequenza con cui risultano essere la spiegazione.

Causa 1: ti connetti con il nome utente sbagliato

La causa più comune è anche la meno interessante. sshd, il demone server SSH (secure shell), non comunica mai che un account non esiste. Esegue l'intero scambio per un nome utente inventato e rifiuta la connessione alla fine con lo stesso messaggio, perché divulgare nomi di account validi aiuta un attaccante. Un errore di battitura nel nome utente appare esattamente come una chiave non funzionante.

Controlla la riga Authenticating to ... as prima di ogni altra cosa. Se indica l'account usato per accedere al laptop invece dell'account sul server, hai omesso il nome utente dal comando.

ssh -v deploy@203.0.113.10
ssh -v root@203.0.113.10

L'account predefinito dipende dall'immagine preparata dal provider. Ad agosto 2026, le immagini cloud Ubuntu usano generalmente un account ubuntu, quelle Debian usano debian o admin, Rocky Linux e AlmaLinux usano rocky e almalinux, mentre molti provider VPS installano direttamente la tua chiave in root. Il pannello di controllo del provider indica quale account è stato creato. Nessun comando eseguito dall'esterno del server può recuperare questa informazione.

Un blocco Host in ~/.ssh/config imposta anch'esso il nome utente e ha la precedenza sul nome dell'account locale:

Host vps-prod
  HostName 203.0.113.10
  User deploy

Se hai creato tu l'account e poi non hai potuto accedere con quell'account, probabilmente la chiave è stata installata per l'utente predefinito dell'immagine e non è mai stata copiata nel nuovo account. Questo passaggio fa parte di primi dieci minuti su un nuovo VPS ed è facile saltarlo.

Causa 2: la chiave che pensi di inviare non è quella effettivamente inviata

Per impostazione predefinita, ssh offre solo le chiavi contenute in ssh-agent e un insieme fisso di nomi di file in ~/.ssh: id_rsa, id_ecdsa, id_ed25519, le varianti per chiavi hardware id_ecdsa_sk e id_ed25519_sk e la chiave ibrida post-quantistica id_mldsa44_ed25519. OpenSSH attuale non supporta più DSA (OpenSSH 10.0 lo ha rimosso ad aprile 2025), quindi un vecchio file id_dsa non viene mai provato. Una chiave salvata come ~/.ssh/vps-prod non è visibile a ssh finché non la specifichi, per questo nell'output dettagliato non compare alcuna riga Offering public key.

Specifica il file e impedisci che le chiavi dell'agent vengano usate al suo posto:

ssh -i ~/.ssh/vps-prod -o IdentitiesOnly=yes deploy@203.0.113.10

-i da solo non è sufficiente quando l'agent contiene chiavi, perché ssh continua a offrire prima le chiavi dell'agent e solo alla fine il file specificato. Questo è importante perché un server che esegue una versione di OpenSSH precedente alla 10.6 conta ogni chiave rifiutata ai fini di MaxAuthTries, il cui valore predefinito è 6. Un agent che contiene sette chiavi può raggiungere il limite prima che venga provata la chiave corretta. OpenSSH 10.6, rilasciato il 6 ottobre 2026, aggiunge la parola chiave max-pk-ok all'opzione sshd esistente PubkeyAuthOptions, con la sintassi PubkeyAuthOptions max-pk-ok:6. Consente al server di controllare fino a quel numero di chiavi offerte, 6 per impostazione predefinita, prima che le successive inizino a essere conteggiate ai fini di MaxAuthTries. Questo aumenta il limite, ma non lo elimina. Quando il limite viene raggiunto, il messaggio cambia in:

Received disconnect from 203.0.113.10 port 22:2: Too many authentication failures

Se visualizzi invece questo messaggio, il server ha interrotto la sessione prima che venisse raggiunta la chiave corretta. Questo problema è descritto in troppi tentativi di autenticazione. IdentitiesOnly=yes limita il tentativo al file specificato. Elenca le chiavi contenute nell'agent con ssh-add -l e cancellale con ssh-add -D se l'agent ha accumulato vecchie chiavi nel corso degli anni. Poi salva queste impostazioni, in modo che il login successivo non dipenda dal ricordare i flag:

Host vps-prod
  HostName 203.0.113.10
  User deploy
  IdentityFile ~/.ssh/vps-prod
  IdentitiesOnly yes

Esiste un'altra situazione problematica lato client. ssh rifiuta di usare una chiave privata che può essere letta da altri account del computer locale. Mostra un avviso e rifiuta di caricare la chiave, quindi la chiave non può essere usata per il login. Tuttavia, non aspettarti che manchi la riga Offering: quando ssh dispone già della parte pubblica, ad esempio dal file .pub presente nella stessa directory, offre quella chiave; il server può rispondere Server accepts key e solo a quel punto ssh carica la chiave privata per firmare, visualizza questo avviso e rinuncia a usare la chiave:

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
Permissions 0644 for '/home/you/.ssh/vps-prod' are too open.

chmod 600 ~/.ssh/vps-prod risolve il problema. Il trasferimento di una chiave tramite una chiavetta USB o una condivisione Windows è il modo più comune con cui la modalità viene modificata. La gestione delle chiavi e la scelta dei relativi nomi sono descritte in Nozioni di base sulla gestione delle chiavi SSH.

Causa 3: la chiave pubblica non è mai arrivata in authorized_keys

Se ssh -v mostra che la chiave viene inviata, ma il server continua a rifiutarla, la domanda successiva è se la chiave si trovi nel file authorized_keys dell'account. Apri la console del provider per verificarlo, perché non puoi accedere tramite SSH per eseguire questo controllo.

sudo ls -l /home/deploy/.ssh/
sudo ssh-keygen -lf /home/deploy/.ssh/authorized_keys

ssh-keygen -lf su un file authorized_keys stampa un'impronta per ogni voce:

256 SHA256:0eL/8sBw... you@laptop (ED25519)
3072 SHA256:9Tq2yZk... old-laptop (RSA)

Confronta queste impronte con quella nella riga Offering public key. Se la chiave è stata inviata in una riga Trying private key, quella riga indica soltanto il file. Recupera quindi l'impronta con ssh-keygen -lf sul file .pub corrispondente. Se la chiave non compare nell'elenco, non è installata nell'account, indipendentemente da ciò che ricordi di aver fatto.

Quattro cause comuni:

  • Hai incollato la chiave privata invece del file .pub. Una riga di chiave pubblica contiene un tipo di chiave come ssh-ed25519, ecdsa-sha2-nistp256 o ssh-rsa, seguito da una lunga stringa base64 e da un commento facoltativo. Opzioni come restrict possono precedere il tipo di chiave. Una chiave privata inizia con -----BEGIN OPENSSH PRIVATE KEY-----.
  • L'incolla ha suddiviso la chiave su più righe. Ogni voce deve occupare una sola riga. Una chiave suddivisa viene quindi interpretata come più voci incomplete e non corrisponde a nulla.
  • La chiave è stata inserita in /root/.ssh/authorized_keys, mentre accedi come deploy, oppure il contrario. Il file è specifico dell'account e non esiste un file condiviso.
  • La casella "add my key" del provider ha scritto la chiave soltanto nell'utente predefinito dell'immagine. L'account creato in seguito ha quindi una directory .ssh vuota.

Il metodo sicuro per aggiungere una chiave dalla console, come root, è il seguente:

sudo install -d -m 700 -o deploy -g deploy /home/deploy/.ssh
sudo tee -a /home/deploy/.ssh/authorized_keys >/dev/null <<'EOF'
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIExampleKeyDataHere you@laptop
EOF
sudo chown deploy:deploy /home/deploy/.ssh/authorized_keys
sudo chmod 600 /home/deploy/.ssh/authorized_keys

Esegui nuovamente sudo ssh-keygen -lf /home/deploy/.ssh/authorized_keys. La nuova impronta dovrebbe ora comparire nell'elenco. Da una macchina che consente ancora l'accesso con password, ssh-copy-id -i ~/.ssh/vps-prod.pub deploy@203.0.113.10 aggiunge la chiave per te e crea .ssh e authorized_keys con permessi restrittivi, se non esistono ancora. Non modifica i permessi di una directory .ssh o di un file authorized_keys già esistente. Controllali quindi come descritto nella causa 4.

Causa 4: perché sshd ignora authorized_keys quando i permessi sono troppo aperti

StrictModes yes è il valore predefinito di sshd. Con questa impostazione, sshd rifiuta di leggere authorized_keys se il file, la directory .ssh o la home directory dell'account possono essere modificati da un utente diverso dal proprietario oppure appartengono all'account sbagliato. Il motivo è diretto: se il gruppo o tutti gli utenti possono scrivere nella home directory, qualsiasi account con questo accesso può sostituire authorized_keys e assumere il controllo dell'accesso. sshd considera non attendibile il percorso e si comporta come se non esistesse alcuna chiave.

Il client visualizza il semplice messaggio Permission denied. Il log del server registra il motivo reale:

Authentication refused: bad ownership or modes for directory /home/deploy/.ssh

oppure, quando il problema riguarda direttamente il file:

Authentication refused: bad ownership or modes for file /home/deploy/.ssh/authorized_keys

Cosa accetta sshd:

  • La home directory: non deve essere scrivibile dal gruppo né da tutti gli utenti. 755, 750 e 700 superano il controllo. 775 e 777 lo falliscono.
  • ~/.ssh: vale la stessa regola. Il manuale di sshd raccomanda l'accesso riservato al solo proprietario, corrispondente alla modalità 700.
  • ~/.ssh/authorized_keys: vale la stessa regola e deve essere un file normale. In caso contrario, il log indica che il percorso is not a regular file. Il manuale raccomanda lettura e scrittura riservate al solo proprietario, corrispondenti alla modalità 600.
  • Proprietà: ogni elemento deve appartenere all'account con cui si effettua l'accesso oppure a root. Qualsiasi altro proprietario fa fallire il controllo.

La proprietà è importante quanto la modalità. sshd legge authorized_keys come account di accesso; quindi, se crei un file con sudo nano e dimentichi di restituirne la proprietà, il file rimane di root con modalità 600. Supera il controllo della proprietà, ma sshd non riesce ad aprirlo e il log segnala invece che non è stato possibile aprire il file. Correggi entrambi gli aspetti in una sola volta:

sudo chown -R deploy:deploy /home/deploy/.ssh
sudo chmod 700 /home/deploy/.ssh
sudo chmod 600 /home/deploy/.ssh/authorized_keys
sudo chmod go-w /home/deploy
ls -ld /home/deploy /home/deploy/.ssh

L'ultimo comando mostra il risultato. La home directory deve avere drwxr-xr-x o permessi più restrittivi, mentre drwx------ deve essere impostato su .ssh. Se queste stringhe non sono ancora chiare, leggi come leggere una stringa di permessi come drwxr-xr-x prima di modificare le modalità su un server in produzione.

Su Rocky Linux e AlmaLinux, aggiungi SELinux (security-enhanced Linux) all'elenco delle possibili cause. Una directory .ssh creata in modo insolito può avere l'etichetta errata, quindi sshd non può leggerla anche se le modalità sono corrette. sudo restorecon -Rv /home/deploy/.ssh ripristina le etichette e sudo ausearch -m avc -ts recent mostra se il componente che ha rifiutato l'accesso era SELinux.

Causa 5: sshd è configurato per rifiutare la connessione

Leggere /etc/ssh/sshd_config non è sufficiente su un sistema Ubuntu o Debian attuale. Il file inizia con Include /etc/ssh/sshd_config.d/*.conf e OpenSSH mantiene il primo valore trovato per ogni impostazione. Un file drop-in come 50-cloud-init.conf viene quindi letto prima del resto del file principale e ha la precedenza su qualsiasi impostazione globale modificata più avanti. L'eccezione è un blocco Match: il manuale di sshd_config specifica che le impostazioni al suo interno hanno la precedenza su quelle definite nella sezione globale. Di conseguenza, un blocco Match corrispondente, anche se si trova alla fine del file principale, prevale su un drop-in per le connessioni a cui si applica. I drop-in vengono letti in ordine lessicale. Un file denominato 00-something.conf viene quindi letto prima di 50-cloud-init.conf e vince il primo file che imposta un determinato valore. Per questo una modifica può sembrare corretta senza produrre alcun effetto.

Chiedi a sshd di mostrare la configurazione effettiva ottenuta da tutti questi file:

sudo sshd -T | grep -Ei 'pubkeyauth|authorizedkeysfile|permitrootlogin|allowusers|allowgroups|denyusers'

sshd -T avvia un nuovo processo di test che legge i file nello stato in cui si trovano in questo momento sul disco. Non interroga l'istanza di sshd già in esecuzione. Una modifica non ancora applicata tramite un riavvio viene quindi mostrata qui prima che il server in esecuzione la utilizzi.

Un risultato corretto è simile al seguente:

permitrootlogin prohibit-password
pubkeyauthentication yes
authorizedkeysfile .ssh/authorized_keys .ssh/authorized_keys2

Controlla questi valori nell'output:

  • pubkeyauthentication no. Nessuna chiave verrà mai accettata. Questo valore compare anche in ssh -v come prima lista Authentications that can continue: senza alcun publickey al suo interno.
  • authorizedkeysfile che punta a un altro percorso, ad esempio /etc/ssh/authorized_keys/%u. In questo caso il file nella directory home viene completamente ignorato e le regole sui permessi della causa 4 si applicano invece al nuovo percorso.
  • Sono presenti allowusers o allowgroups. Qualsiasi account non elencato viene rifiutato con esattamente questo errore e senza spiegazioni. denyusers e denygroups producono lo stesso effetto in senso inverso.
  • permitrootlogin no mentre provi ad accedere come root. prohibit-password è l'impostazione intermedia utile: root può usare una chiave, ma non una password.

I blocchi Match non compaiono in un semplice sshd -T, perché il risultato dipende dall'identità dell'utente che si connette. Interroga una connessione specifica:

sudo sshd -T -C user=deploy,host=vps.example.com,addr=198.51.100.7

Un'altra impostazione riguarda le chiavi meno recenti. OpenSSH 8.8 ha smesso di accettare per impostazione predefinita le firme SHA-1 (ssh-rsa). Di conseguenza, una chiave RSA che ha funzionato per anni può smettere di funzionare dopo un aggiornamento su un'estremità, se l'altra è troppo vecchia per usare RSA con SHA-256. Un client attuale che comunica con un server così obsoleto lo segnala chiaramente:

debug1: send_pubkey_test: no mutual signature algorithm

Di solito la chiave è corretta. Le note di rilascio di OpenSSH 8.8 specificano che non è necessario sostituire le chiavi ssh-rsa, perché passano a RSA/SHA-256 o RSA/SHA-512 quando entrambe le estremità lo supportano. L'aggiornamento dell'estremità obsoleta è quindi la soluzione definitiva. Se non puoi aggiornarla, funziona anche una nuova chiave, purché l'estremità obsoleta esegua OpenSSH 6.5 o versione successiva, la versione che ha introdotto Ed25519. Esegui ssh-keygen -t ed25519 -C "deploy@vps-prod", quindi installa il file .pub come mostrato sopra. Un'estremità precedente alla 6.5 non supporta né Ed25519 né RSA con SHA-256. In questo caso una nuova chiave Ed25519 non è sufficiente. Impostare PubkeyAcceptedAlgorithms +ssh-rsa sull'estremità aggiornata, in un blocco Host del file ~/.ssh/config del client oppure nella configurazione di sshd del server, riabilita le vecchie firme e consente di accedere subito al sistema. Consideralo quindi un modo per raggiungere il server, non la conclusione dell'intervento. Le altre impostazioni lato server che vale la pena verificare sono illustrate in rafforzare la sicurezza del server SSH su un VPS.

Come dimostrare che una chiave privata corrisponde alla chiave pubblica installata

Gran parte delle supposizioni in questo errore deriva dal non sapere se due file formano una coppia. Un comando permette di verificarlo:

ssh-keygen -y -f ~/.ssh/vps-prod

Questo comando visualizza la chiave pubblica derivata dalla chiave privata. Non legge mai il file .pub associato, quindi mostra quale chiave privata è realmente presente, invece di basarsi su ciò che dichiara un file .pub obsoleto. Se la chiave ha una passphrase, il comando la richiede. Questo dimostra anche che si conosce ancora la passphrase.

ssh-keygen -lf ~/.ssh/vps-prod.pub
ssh-add -l

Il primo comando visualizza l'impronta digitale di un file contenente una chiave pubblica. Il secondo visualizza le impronte delle chiavi gestite dall'agent. Confrontare ora quattro rappresentazioni della stessa stringa: l'impronta nella riga Offering public key restituita da ssh -v, l'impronta del file .pub, le impronte in ssh-keygen -lf nel file authorized_keys del server e l'impronta nel log del server. Il punto in cui i valori non corrispondono più identifica l'origine del problema.

Leggere il log del server mentre l'accesso non riesce

Al client non viene comunicato volutamente nulla di utile. Il server registra il motivo effettivo. Avviare un monitor del log nella sessione console, quindi eseguire dal laptop il comando ssh che non riesce.

sudo journalctl -u ssh -f

L'immagine cloud standard di Ubuntu 24.04 per i server installa rsyslog per impostazione predefinita; il relativo manifest dei pacchetti lo elenca al 3 novembre 2026. Gli stessi record vengono quindi scritti anche in /var/log/auth.log. Le immagini cloud minimal di Ubuntu 24.04 vengono distribuite senza rsyslog. In queste immagini auth.log non esiste per impostazione predefinita e il journal è il punto da consultare. In Rocky Linux e AlmaLinux l'unità si chiama sshd e gli stessi record vengono scritti anche in /var/log/secure.

Impostare LogLevel VERBOSE nella configurazione di sshd e ricaricare il servizio. Ogni tentativo registra quindi l'impronta digitale ricevuta effettivamente dal server:

Failed publickey for deploy from 198.51.100.7 port 49812 ssh2: ED25519 SHA256:0eL/8sBw...

Questa riga indica su quale lato si trova il problema. Un'impronta riconosciuta significa che la chiave è arrivata al server, ma è stata rifiutata. Esaminare quindi le cause 3, 4 e 5. Un'impronta non riconosciuta significa che il client ha inviato una chiave diversa da quella prevista. Tornare quindi alla causa 2.

Quando il log non è ancora chiaro, avviare un secondo sshd su un'altra porta in modalità debug. Il processo resta in primo piano, gestisce una connessione, stampa le motivazioni, quindi termina:

sudo /usr/sbin/sshd -ddd -p 2222

Dalla sessione console sullo stesso server, connettersi usando l'indirizzo di loopback:

ssh -p 2222 -i ~/.ssh/vps-prod -o IdentitiesOnly=yes deploy@127.0.0.1

Usare 127.0.0.1 esclude dal test la rete tra il client e il server. Il traffico di loopback passa comunque attraverso il filtro dei pacchetti del kernel. Su Ubuntu, però, le regole predefinite di ufw accettano tutto sull'interfaccia lo. La porta 2222 non richiede quindi una regola firewall dedicata, a meno che qualcuno non abbia rimosso questa impostazione predefinita. L'output di debug indica il file aperto, l'impronta confrontata e il rifiuto esatto, incluse righe come Authentication refused: bad ownership or modes for directory /home/deploy. Premere Ctrl+C quando si è individuata la causa. Il processo sshd effettivo sulla porta 22 non viene modificato durante tutta la procedura.

Come evitare di bloccare l'accesso al server

Ogni modifica alla configurazione del server deve prevedere un metodo di accesso alternativo che non dipenda da SSH. Configuralo mentre SSH funziona ancora, non dopo che si è interrotto.

  1. Apri la console del provider tramite seriale o VNC (virtual network computing) e verifica di riuscire ad accedere.
  2. Assicurati di conoscere una password locale funzionante per un account con sudo. Se non ne hai una, reimposta prima la password di root dalla console del provider.
  3. Lascia aperta la sessione SSH corrente. Una sessione aperta sopravvive a systemctl restart ssh, quindi rimane un metodo di accesso se la nuova configurazione è errata.
  4. Verifica la sintassi prima di riavviare: sudo sshd -t non stampa nulla quando il file è valido e stampa il file e il numero di riga quando non lo è.
  5. Apri un secondo terminale ed effettua un nuovo accesso prima di chiudere il primo. Una configurazione errata impedisce i nuovi accessi ma lascia attivi quelli esistenti, quindi la sessione già aperta non può confermare se la modifica ha funzionato.

Riavvia con sudo systemctl restart ssh su Debian e Ubuntu oppure con sudo systemctl restart sshd su Rocky Linux e AlmaLinux. Su Ubuntu 24.04, sshd viene avviato da una socket unit, la cui porta e il cui indirizzo provengono da sshd_config tramite un generatore systemd. Per rendere effettiva una modifica a Port o ListenAddress, devi quindi eseguire anche sudo systemctl daemon-reload e poi sudo systemctl restart ssh.socket.

FAQ

Perché ricevo Permission denied (publickey) quando la stessa chiave funziona su un altro server?

La chiave è valida, ma c'è un problema nell'ambiente circostante. Esegui ssh -v e cerca la riga Offering public key o Trying private key relativa alla tua chiave. Se la chiave non è elencata in nessuno dei due casi, ssh non l'ha inviata: il file non si trova in ~/.ssh con un nome predefinito e la chiave non è stata caricata nell'agent, quindi aggiungi -i /path/to/key -o IdentitiesOnly=yes. Se la chiave è elencata ma il server continua a rifiutarla, la chiave non è presente nel authorized_keys dell'account, il percorso che la contiene è scrivibile dal gruppo oppure la configurazione di sshd blocca l'utente. Il log del server permette di distinguere questi casi.

Come posso vedere quale chiave SSH sta effettivamente inviando?

ssh -v host stampa una riga debug1: Offering public key: per ogni chiave di cui possiede già la parte pubblica, indicando il tipo di chiave e un'impronta digitale SHA256. Una chiave letta da un file indica quel file, mentre una chiave presente soltanto nell'agent mostra il relativo commento dell'agent; agent alla fine della riga indica le chiavi fornite dall'agent. Se la riga successiva è send_pubkey_test: no mutual signature algorithm, la chiave non è stata comunque inviata. Per una chiave di cui ssh non ha potuto leggere in anticipo la parte pubblica non viene stampata alcuna riga Offering: ssh stampa Trying private key: con il nome del file, carica la chiave privata e invia direttamente una richiesta firmata. ssh-add -l elenca le impronte digitali presenti nell'agent. ssh-keygen -lf ~/.ssh/id_ed25519.pub stampa l'impronta digitale di un singolo file di chiave, mentre ssh-keygen -y -f ~/.ssh/id_ed25519 stampa la chiave pubblica derivata effettivamente da una chiave privata. Perché l'accesso abbia esito positivo, l'impronta digitale della chiave inviata deve comparire anche nell'output di ssh-keygen -lf eseguito sul server con authorized_keys.

Perché sshd ignora il mio file authorized_keys?

Perché StrictModes è attivo per impostazione predefinita e il file, la directory .ssh oppure la directory home è scrivibile dal gruppo o da chiunque, oppure appartiene a un account diverso da te o da root. sshd non considera attendibile un percorso che altri possono modificare, quindi si comporta come se non esistesse alcuna chiave. Il controllo richiede che nessuno dei tre elementi sia scrivibile dal gruppo o da altri, che ciascuno appartenga all'account di accesso o a root e che authorized_keys sia un file regolare; per questo, rimuovere soltanto i permessi di scrittura non è sempre sufficiente. L'impostazione sicura consiste nell'usare 755 o permessi più restrittivi sulla directory home, 700 su .ssh e 600 su authorized_keys, assegnando tutti gli elementi all'account di accesso. Con LogLevel VERBOSE il server registra Authentication refused: bad ownership or modes for directory /home/deploy/.ssh.

La mia chiave ha smesso di funzionare subito dopo un aggiornamento del server. Che cosa è cambiato?

Se si tratta di una chiave RSA, la causa più probabile è la modifica relativa a SHA-1. OpenSSH 8.8 ha disabilitato per impostazione predefinita le firme SHA-1 ssh-rsa, quindi una chiave RSA viene rifiutata quando l'altra estremità può usarla soltanto in quel modo. Un client aggiornato mostra debug1: send_pubkey_test: no mutual signature algorithm. Non è necessario sostituire la chiave se puoi aggiornare l'estremità obsoleta, perché le chiavi RSA usano SHA-256 o SHA-512 quando entrambe le estremità lo supportano. Se non puoi farlo e l'estremità obsoleta esegue OpenSSH 6.5 o una versione successiva, genera una chiave moderna con ssh-keygen -t ed25519 e installa il relativo file .pub. Un'estremità precedente alla versione 6.5 non supporta né Ed25519 né RSA con SHA-256, quindi una nuova chiave non risolve questo caso. Se ti serve accedere immediatamente, PubkeyAcceptedAlgorithms +ssh-rsa sul lato aggiornato riattiva le vecchie firme; rimuovi quella riga quando avrai applicato la soluzione definitiva.

Ho modificato sshd_config e ora non riesco più ad accedere. Come posso ripristinare l'accesso?

Usa la console del provider, che non passa attraverso SSH. Accedi con una password locale, esegui sudo sshd -t per visualizzare l'errore di sintassi e il relativo numero di riga, annulla la modifica e riavvia il servizio. Esegui quindi sudo sshd -T per visualizzare i valori effettivi prodotti dai file attualmente presenti, perché un file in /etc/ssh/sshd_config.d/ potrebbe sovrascrivere la configurazione principale. Il comando legge nuovamente i file invece di interrogare il processo sshd in esecuzione, quindi dopo ogni ulteriore modifica devi riavviare il servizio prima di verificare l'accesso. Se non hai una password locale, reimposta prima la password di root dalla console, quindi correggi il file.

Questo articolo ti è stato utile?